/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 4.0.0
 *
 * 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.
 * ----------------------------------------------------------------------------- */

#include <cmath>



#ifndef SWIGPYTHON
#define SWIGPYTHON
#endif

#define SWIG_DIRECTORS
#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 defined(__GNUC__)
#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#    ifndef GCC_HASCLASSVISIBILITY
#      define GCC_HASCLASSVISIBILITY
#    endif
#  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(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include <math.h>
#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 1
#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
#define SWIG_POINTER_NO_NULL       0x4

/* 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 = (unsigned char)((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = (unsigned char)((d - ('a'-10)) << 4);
    else
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (unsigned char)(d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (unsigned char)(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 *newstr = 0;
  str = PyUnicode_AsUTF8String(str);
  if (str) {
    char *cstr;
    Py_ssize_t len;
    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
}

#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif

// SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user
// interface files check for it.
# define SWIGPY_USE_CAPSULE
# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)

#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#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) {
    PyObject *old_str = PyObject_Str(value);
    const char *tmp = SWIG_Python_str_AsChar(old_str);
    PyErr_Clear();
    Py_XINCREF(type);
    if (tmp)
      PyErr_Format(type, "%s %s", tmp, mesg);
    else
      PyErr_Format(type, "%s", mesg);
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(old_str);
    Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
  PyObject *error;
  if (obj)
    return 0;
  error = PyErr_Occurred();
  return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}

SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
  if (SWIG_Python_TypeErrorOccurred(NULL)) {
    /* Use existing TypeError to preserve stacktrace and enhance with given message */
    PyObject *newvalue;
    PyObject *type = NULL, *value = NULL, *traceback = NULL;
    PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
    newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
    newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
    Py_XDECREF(value);
    PyErr_Restore(type, newvalue, traceback);
  } else {
    /* Raise TypeError using given message */
    PyErr_SetString(PyExc_TypeError, message);
  }
}

#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)
#    define SWIG_PYTHON_USE_GIL
#  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;
  const char *name;
  long lvalue;
  double dvalue;
  void   *pvalue;
  swig_type_info **ptype;
} swig_const_info;

#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.
 *
 * ----------------------------------------------------------------------------- */

#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif

#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000
# error "This version of SWIG only supports Python 3 >= 3.2"
#endif

/* 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) {   
  PyDict_SetItemString(d, name, obj);
  Py_DECREF(obj);
  if (public_interface)
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}

#else

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  Py_DECREF(obj);                            
}

#endif

/* Append a value to the result obj */

SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
  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;
}

/* Unpack the argument tuple */

SWIGINTERN Py_ssize_t
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) {
      Py_ssize_t 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 {
      Py_ssize_t 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 */
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunction(functor, (char *)"O", obj);

/*
  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

/* Method creation and docstring support functions */

SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name);
SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);

/* 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;
  int fail = data ? data->implicitconv : 0;
  if (fail)
    PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
  return fail;
}

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 {
      data->newraw = PyObject_GetAttrString(data->klass, "__new__");
      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, "__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);
      data->delargs = !(flags & (METH_O));
    } 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 *
SwigPyObject_repr(SwigPyObject *v)
{
  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) {
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
# 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;  
}

/* We need a version taking two PyObject* parameters so it's a valid
 * PyCFunction to use in swigobject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  return SwigPyObject_repr((SwigPyObject*)v);
}

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;

      /* PyObject_CallFunction() has the potential to silently drop
         the active exception.  In cases of unnamed temporary
         variable or where we just finished iterating over a generator
         StopIteration will be active right now, and this needs to
         remain true upon return from SwigPyObject_dealloc.  So save
         and restore. */
      
      PyObject *type = NULL, *value = NULL, *traceback = NULL;
      PyErr_Fetch(&type, &value, &traceback);

      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));
      }
      if (!res)
        PyErr_WriteUnraisable(destroy);

      PyErr_Restore(type, value, traceback);

      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;
  if (!SwigPyObject_Check(next)) {
    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    return NULL;
  }
  sobj->next = next;
  Py_INCREF(next);
  return SWIG_Py_Void();
}

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

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

SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  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 (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
    return NULL;
  } else {
    SwigPyObject *sobj = (SwigPyObject *)v;
    PyObject *obj = PyBool_FromLong(sobj->own);
    if (val) {
      if (PyObject_IsTrue(val)) {
        SwigPyObject_acquire(v,args);
      } else {
        SwigPyObject_disown(v,args);
      }
    } 
    return obj;
  }
}

static PyMethodDef
swigobject_methods[] = {
  {"disown",  SwigPyObject_disown,  METH_NOARGS,  "releases ownership of the pointer"},
  {"acquire", SwigPyObject_acquire, METH_NOARGS,  "acquires ownership of the pointer"},
  {"own",     SwigPyObject_own,     METH_VARARGS, "returns/sets ownership of the pointer"},
  {"append",  SwigPyObject_append,  METH_O,       "appends another 'this' object"},
  {"next",    SwigPyObject_next,    METH_NOARGS,  "returns the next 'this' object"},
  {"__repr__",SwigPyObject_repr2,   METH_NOARGS,  "returns object representation"},
  {0, 0, 0, 0}  
};

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 >= 0x03050000 /* 3.5 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif 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 */
#else
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
  };

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      "SwigPyObject",                       /* tp_name */
      sizeof(SwigPyObject),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
      0,                                    /* tp_print */
      (getattrfunc)0,                       /* tp_getattr */
      (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 */
      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 */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    swigpyobject_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpyobject_type) < 0)
      return NULL;
  }
  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 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((const char *)v->pack, (const 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 = {
#if PY_VERSION_HEX>=0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      "SwigPyPacked",                       /* tp_name */
      sizeof(SwigPyPacked),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
      0,                                    /* 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 */
      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 */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    swigpypacked_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpypacked_type) < 0)
      return NULL;
  }
  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
 * ----------------------------------------------------------------------------- */

static PyObject *Swig_This_global = NULL;

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  if (Swig_This_global == NULL)
    Swig_This_global = SWIG_Python_str_FromChar("this");
  return Swig_This_global;
}

/* #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)
  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 (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : 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;
    swig_cast_info *tc;

    /* 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;
    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;
    }
    return SWIG_OK;
  }
}

/* Convert a packed pointer 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)
{
  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
    PyObject *empty_args = PyTuple_New(0);
    if (empty_args) {
      PyObject *empty_kwargs = PyDict_New();
      if (empty_kwargs) {
        inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
        Py_DECREF(empty_kwargs);
        if (inst) {
          PyObject_SetAttr(inst, SWIG_This(), swig_this);
          Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
        }
      }
      Py_DECREF(empty_args);
    }
#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;
}

SWIGRUNTIME void
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
 PyObject *dict;
#if !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, "__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
    type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
    if (PyErr_Occurred()) {
      PyErr_Clear();
      type_pointer = (void *)0;
    }
#endif
  }
  return (swig_module_info *) type_pointer;
}

SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
  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_global = 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("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
  PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && module) {
    PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
  } else {
    Py_XDECREF(pointer);
  }
}

/* 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) {
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
  } else {
    swig_module_info *swig_module = SWIG_GetModule(0);
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
      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) {
      PyObject *old_str = PyObject_Str(value);
      const char *tmp = SWIG_Python_str_AsChar(old_str);
      const char *errmesg = tmp ? tmp : "Invalid error message";
      Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, errmesg);
      } else {
	PyErr_Format(type, "%s %s", errmesg, 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);
      if (!encoded_name)
        return -1;
    }
    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) 

/* -----------------------------------------------------------------------------
 * director_common.swg
 *
 * This file contains support for director classes which is common between
 * languages.
 * ----------------------------------------------------------------------------- */

/*
  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
  'Swig' namespace. This could be useful for multi-modules projects.
*/
#ifdef SWIG_DIRECTOR_STATIC
/* Force anonymous (static) namespace */
#define Swig
#endif
/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes so that Python proxy
 * methods can be called from C++.
 * ----------------------------------------------------------------------------- */

#ifndef SWIG_DIRECTOR_PYTHON_HEADER_
#define SWIG_DIRECTOR_PYTHON_HEADER_

#include <string>
#include <iostream>
#include <exception>
#include <vector>
#include <map>


/*
  Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual
  table', and avoid multiple GetAttr calls to retrieve the python
  methods.
*/

#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE
#ifndef SWIG_PYTHON_DIRECTOR_VTABLE
#define SWIG_PYTHON_DIRECTOR_VTABLE
#endif
#endif



/*
  Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the
  Undefined Exception Handler provided by swig.
*/
#ifndef SWIG_DIRECTOR_NO_UEH
#ifndef SWIG_DIRECTOR_UEH
#define SWIG_DIRECTOR_UEH
#endif
#endif


/*
  Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the
  native C++ RTTI and dynamic_cast<>. But be aware that directors
  could stop working when using this option.
*/
#ifdef SWIG_DIRECTOR_NORTTI
/*
   When we don't use the native C++ RTTI, we implement a minimal one
   only for Directors.
*/
# ifndef SWIG_DIRECTOR_RTDIR
# define SWIG_DIRECTOR_RTDIR

namespace Swig {
  class Director;
  SWIGINTERN std::map<void *, Director *>& get_rtdir_map() {
    static std::map<void *, Director *> rtdir_map;
    return rtdir_map;
  }

  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) {
    get_rtdir_map()[vptr] = rtdir;
  }

  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
    std::map<void *, Director *>::const_iterator pos = get_rtdir_map().find(vptr);
    Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0;
    return rtdir;
  }
}
# endif /* SWIG_DIRECTOR_RTDIR */

# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast<void *>(ARG))
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast<void *>(ARG1), ARG2)

#else

# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2)

#endif /* SWIG_DIRECTOR_NORTTI */

extern "C" {
  struct swig_type_info;
}

namespace Swig {

  /* memory handler */
  struct GCItem {
    virtual ~GCItem() {}

    virtual int get_own() const {
      return 0;
    }
  };

  struct GCItem_var {
    GCItem_var(GCItem *item = 0) : _item(item) {
    }

    GCItem_var& operator=(GCItem *item) {
      GCItem *tmp = _item;
      _item = item;
      delete tmp;
      return *this;
    }

    ~GCItem_var() {
      delete _item;
    }

    GCItem * operator->() const {
      return _item;
    }

  private:
    GCItem *_item;
  };

  struct GCItem_Object : GCItem {
    GCItem_Object(int own) : _own(own) {
    }

    virtual ~GCItem_Object() {
    }

    int get_own() const {
      return _own;
    }

  private:
    int _own;
  };

  template <typename Type>
  struct GCItem_T : GCItem {
    GCItem_T(Type *ptr) : _ptr(ptr) {
    }

    virtual ~GCItem_T() {
      delete _ptr;
    }

  private:
    Type *_ptr;
  };

  template <typename Type>
  struct GCArray_T : GCItem {
    GCArray_T(Type *ptr) : _ptr(ptr) {
    }

    virtual ~GCArray_T() {
      delete[] _ptr;
    }

  private:
    Type *_ptr;
  };

  /* base class for director exceptions */
  class DirectorException : public std::exception {
  protected:
    std::string swig_msg;
  public:
    DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (msg[0]) {
        swig_msg += " ";
        swig_msg += msg;
      }
      if (!PyErr_Occurred()) {
        PyErr_SetString(error, what());
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
    }

    virtual ~DirectorException() throw() {
    }

    /* Deprecated, use what() instead */
    const char *getMessage() const {
      return what();
    }

    const char *what() const throw() {
      return swig_msg.c_str();
    }

    static void raise(PyObject *error, const char *msg) {
      throw DirectorException(error, msg);
    }

    static void raise(const char *msg) {
      raise(PyExc_RuntimeError, msg);
    }
  };

  /* unknown exception handler  */
  class UnknownExceptionHandler {
#ifdef SWIG_DIRECTOR_UEH
    static void handler() {
      try {
        throw;
      } catch (DirectorException& e) {
        std::cerr << "SWIG Director exception caught:" << std::endl
                  << e.what() << std::endl;
      } catch (std::exception& e) {
        std::cerr << "std::exception caught: "<< e.what() << std::endl;
      } catch (...) {
        std::cerr << "Unknown exception caught." << std::endl;
      }

      std::cerr << std::endl
                << "Python interpreter traceback:" << std::endl;
      PyErr_Print();
      std::cerr << std::endl;

      std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl
                << "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl
                << std::endl
                << "Exception is being re-thrown, program will likely abort/terminate." << std::endl;
      throw;
    }

  public:

    std::unexpected_handler old;
    UnknownExceptionHandler(std::unexpected_handler nh = handler) {
      old = std::set_unexpected(nh);
    }

    ~UnknownExceptionHandler() {
      std::set_unexpected(old);
    }
#endif
  };

  /* type mismatch in the return value from a python method call */
  class DirectorTypeMismatchException : public DirectorException {
  public:
    DirectorTypeMismatchException(PyObject *error, const char *msg="")
      : DirectorException(error, "SWIG director type mismatch", msg) {
    }

    DirectorTypeMismatchException(const char *msg="")
      : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) {
    }

    static void raise(PyObject *error, const char *msg) {
      throw DirectorTypeMismatchException(error, msg);
    }

    static void raise(const char *msg) {
      throw DirectorTypeMismatchException(msg);
    }
  };

  /* any python exception that occurs during a director method call */
  class DirectorMethodException : public DirectorException {
  public:
    DirectorMethodException(const char *msg = "")
      : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) {
    }

    static void raise(const char *msg) {
      throw DirectorMethodException(msg);
    }
  };

  /* attempt to call a pure virtual method via a director method */
  class DirectorPureVirtualException : public DirectorException {
  public:
    DirectorPureVirtualException(const char *msg = "")
      : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) {
    }

    static void raise(const char *msg) {
      throw DirectorPureVirtualException(msg);
    }
  };


#if defined(SWIG_PYTHON_THREADS)
/*  __THREAD__ is the old macro to activate some thread support */
# if !defined(__THREAD__)
#   define __THREAD__ 1
# endif
#endif

#ifdef __THREAD__
# include "pythread.h"
  class Guard {
    PyThread_type_lock &mutex_;

  public:
    Guard(PyThread_type_lock & mutex) : mutex_(mutex) {
      PyThread_acquire_lock(mutex_, WAIT_LOCK);
    }

    ~Guard() {
      PyThread_release_lock(mutex_);
    }
  };
# define SWIG_GUARD(mutex) Guard _guard(mutex)
#else
# define SWIG_GUARD(mutex)
#endif

  /* director base class */
  class Director {
  private:
    /* pointer to the wrapped python object */
    PyObject *swig_self;
    /* flag indicating whether the object is owned by python or c++ */
    mutable bool swig_disown_flag;

    /* decrement the reference count of the wrapped python object */
    void swig_decref() const {
      if (swig_disown_flag) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        Py_DECREF(swig_self);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }

  public:
    /* wrap a python object. */
    Director(PyObject *self) : swig_self(self), swig_disown_flag(false) {
    }

    /* discard our reference at destruction */
    virtual ~Director() {
      swig_decref();
    }

    /* return a pointer to the wrapped python object */
    PyObject *swig_get_self() const {
      return swig_self;
    }

    /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */
    void swig_disown() const {
      if (!swig_disown_flag) {
        swig_disown_flag=true;
        swig_incref();
      }
    }

    /* increase the reference count of the wrapped python object */
    void swig_incref() const {
      if (swig_disown_flag) {
        Py_INCREF(swig_self);
      }
    }

    /* methods to implement pseudo protected director members */
    virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const {
      return true;
    }

    virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const {
    }

  /* ownership management */
  private:
    typedef std::map<void *, GCItem_var> swig_ownership_map;
    mutable swig_ownership_map swig_owner;
#ifdef __THREAD__
    static PyThread_type_lock swig_mutex_own;
#endif

  public:
    template <typename Type>
    void swig_acquire_ownership_array(Type *vptr) const {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCArray_T<Type>(vptr);
      }
    }

    template <typename Type>
    void swig_acquire_ownership(Type *vptr) const {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_T<Type>(vptr);
      }
    }

    void swig_acquire_ownership_obj(void *vptr, int own) const {
      if (vptr && own) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_Object(own);
      }
    }

    int swig_release_ownership(void *vptr) const {
      int own = 0;
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_ownership_map::iterator iter = swig_owner.find(vptr);
        if (iter != swig_owner.end()) {
          own = iter->second->get_own();
          swig_owner.erase(iter);
        }
      }
      return own;
    }

    template <typename Type>
    static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) {
      SwigPyObject *sobj = (SwigPyObject *)pyobj;
      sobj->own = 0;
      Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast<Type *>(sobj->ptr));
      if (d)
        d->swig_disown();
      return PyWeakref_NewProxy(pyobj, NULL);
    }
  };

#ifdef __THREAD__
  PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock();
#endif
}

#endif

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

#define SWIGTYPE_p_ArcIterator swig_types[0]
#define SWIGTYPE_p_BNGenerator swig_types[1]
#define SWIGTYPE_p_EdgeIterator swig_types[2]
#define SWIGTYPE_p_IDGenerator swig_types[3]
#define SWIGTYPE_p_JunctionTreeGenerator swig_types[4]
#define SWIGTYPE_p_NodeConstIterator swig_types[5]
#define SWIGTYPE_p_NodeConstIteratorSafe swig_types[6]
#define SWIGTYPE_p_NodeIterator swig_types[7]
#define SWIGTYPE_p_NodeIteratorSafe swig_types[8]
#define SWIGTYPE_p_PRMexplorer swig_types[9]
#define SWIGTYPE_p_PythonApproximationListener swig_types[10]
#define SWIGTYPE_p_PythonBNListener swig_types[11]
#define SWIGTYPE_p_PythonDatabaseGeneratorListener swig_types[12]
#define SWIGTYPE_p_PythonLoadListener swig_types[13]
#define SWIGTYPE_p_allocator_type swig_types[14]
#define SWIGTYPE_p_char swig_types[15]
#define SWIGTYPE_p_difference_type swig_types[16]
#define SWIGTYPE_p_gum__ApproximationScheme swig_types[17]
#define SWIGTYPE_p_gum__Arc swig_types[18]
#define SWIGTYPE_p_gum__ArcGraphPart swig_types[19]
#define SWIGTYPE_p_gum__BNdistanceT_double_t swig_types[20]
#define SWIGTYPE_p_gum__BayesNetInferenceT_double_t swig_types[21]
#define SWIGTYPE_p_gum__BayesNetT_double_t swig_types[22]
#define SWIGTYPE_p_gum__CPTError swig_types[23]
#define SWIGTYPE_p_gum__CPTNoSumTo1 swig_types[24]
#define SWIGTYPE_p_gum__CliqueGraph swig_types[25]
#define SWIGTYPE_p_gum__DAG swig_types[26]
#define SWIGTYPE_p_gum__DAGmodel swig_types[27]
#define SWIGTYPE_p_gum__DatabaseError swig_types[28]
#define SWIGTYPE_p_gum__DefaultInLabel swig_types[29]
#define SWIGTYPE_p_gum__DiGraph swig_types[30]
#define SWIGTYPE_p_gum__DiscreteVariable swig_types[31]
#define SWIGTYPE_p_gum__DiscretizedVariableT_double_t swig_types[32]
#define SWIGTYPE_p_gum__DuplicateElement swig_types[33]
#define SWIGTYPE_p_gum__DuplicateLabel swig_types[34]
#define SWIGTYPE_p_gum__Edge swig_types[35]
#define SWIGTYPE_p_gum__EdgeGraphPart swig_types[36]
#define SWIGTYPE_p_gum__EmptyBSTree swig_types[37]
#define SWIGTYPE_p_gum__EmptySet swig_types[38]
#define SWIGTYPE_p_gum__EssentialGraph swig_types[39]
#define SWIGTYPE_p_gum__ExactBNdistanceT_double_t swig_types[40]
#define SWIGTYPE_p_gum__Exception swig_types[41]
#define SWIGTYPE_p_gum__FactoryError swig_types[42]
#define SWIGTYPE_p_gum__FactoryInvalidState swig_types[43]
#define SWIGTYPE_p_gum__FatalError swig_types[44]
#define SWIGTYPE_p_gum__FormatNotFound swig_types[45]
#define SWIGTYPE_p_gum__GibbsBNdistanceT_double_t swig_types[46]
#define SWIGTYPE_p_gum__GibbsSamplingT_double_t swig_types[47]
#define SWIGTYPE_p_gum__GraphError swig_types[48]
#define SWIGTYPE_p_gum__IApproximationSchemeConfiguration swig_types[49]
#define SWIGTYPE_p_gum__IBayesNetT_double_t swig_types[50]
#define SWIGTYPE_p_gum__IDiscretizedVariable swig_types[51]
#define SWIGTYPE_p_gum__IOError swig_types[52]
#define SWIGTYPE_p_gum__IdError swig_types[53]
#define SWIGTYPE_p_gum__ImportanceSamplingT_double_t swig_types[54]
#define SWIGTYPE_p_gum__IncompatibleEvidence swig_types[55]
#define SWIGTYPE_p_gum__IncompatibleScoreApriori swig_types[56]
#define SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t swig_types[57]
#define SWIGTYPE_p_gum__InfluenceDiagramT_double_t swig_types[58]
#define SWIGTYPE_p_gum__Instantiation swig_types[59]
#define SWIGTYPE_p_gum__InvalidArc swig_types[60]
#define SWIGTYPE_p_gum__InvalidArgument swig_types[61]
#define SWIGTYPE_p_gum__InvalidArgumentsNumber swig_types[62]
#define SWIGTYPE_p_gum__InvalidDirectedCycle swig_types[63]
#define SWIGTYPE_p_gum__InvalidEdge swig_types[64]
#define SWIGTYPE_p_gum__InvalidNode swig_types[65]
#define SWIGTYPE_p_gum__LabelizedVariable swig_types[66]
#define SWIGTYPE_p_gum__LazyPropagationT_double_t swig_types[67]
#define SWIGTYPE_p_gum__LearningError swig_types[68]
#define SWIGTYPE_p_gum__ListT_gum__PotentialT_double_t_const_p_t swig_types[69]
#define SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t swig_types[70]
#define SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t swig_types[71]
#define SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t swig_types[72]
#define SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t swig_types[73]
#define SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t swig_types[74]
#define SWIGTYPE_p_gum__MarkovBlanket swig_types[75]
#define SWIGTYPE_p_gum__MissingValueInDatabase swig_types[76]
#define SWIGTYPE_p_gum__MissingVariableInDatabase swig_types[77]
#define SWIGTYPE_p_gum__MixedGraph swig_types[78]
#define SWIGTYPE_p_gum__MonteCarloSamplingT_double_t swig_types[79]
#define SWIGTYPE_p_gum__MultiDimAdressable swig_types[80]
#define SWIGTYPE_p_gum__MultiDimArrayT_double_t swig_types[81]
#define SWIGTYPE_p_gum__MultiDimContainerT_double_t swig_types[82]
#define SWIGTYPE_p_gum__MultiDimDecoratorT_double_t swig_types[83]
#define SWIGTYPE_p_gum__MultiDimImplementationT_double_t swig_types[84]
#define SWIGTYPE_p_gum__MultiDimInterface swig_types[85]
#define SWIGTYPE_p_gum__MultiDimWithOffsetT_double_t swig_types[86]
#define SWIGTYPE_p_gum__NoChild swig_types[87]
#define SWIGTYPE_p_gum__NoNeighbour swig_types[88]
#define SWIGTYPE_p_gum__NoParent swig_types[89]
#define SWIGTYPE_p_gum__NodeGraphPart swig_types[90]
#define SWIGTYPE_p_gum__NodePropertyT_gum__PotentialT_double_t_const_p_t swig_types[91]
#define SWIGTYPE_p_gum__NodePropertyT_std__size_t_t swig_types[92]
#define SWIGTYPE_p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t swig_types[93]
#define SWIGTYPE_p_gum__NotFound swig_types[94]
#define SWIGTYPE_p_gum__NotImplementedYet swig_types[95]
#define SWIGTYPE_p_gum__NullElement swig_types[96]
#define SWIGTYPE_p_gum__OperationNotAllowed swig_types[97]
#define SWIGTYPE_p_gum__OutOfBounds swig_types[98]
#define SWIGTYPE_p_gum__OutOfLowerBound swig_types[99]
#define SWIGTYPE_p_gum__OutOfUpperBound swig_types[100]
#define SWIGTYPE_p_gum__PossiblyIncompatibleScoreApriori swig_types[101]
#define SWIGTYPE_p_gum__PotentialT_double_t swig_types[102]
#define SWIGTYPE_p_gum__RangeVariable swig_types[103]
#define SWIGTYPE_p_gum__ReferenceError swig_types[104]
#define SWIGTYPE_p_gum__SequenceT_gum__DiscreteVariable_const_p_t swig_types[105]
#define SWIGTYPE_p_gum__SequenceT_std__size_t_t swig_types[106]
#define SWIGTYPE_p_gum__SetIteratorStaticEnd swig_types[107]
#define SWIGTYPE_p_gum__SetT_gum__Arc_t swig_types[108]
#define SWIGTYPE_p_gum__SetT_gum__Arc_t__const_iterator swig_types[109]
#define SWIGTYPE_p_gum__SetT_gum__Edge_t swig_types[110]
#define SWIGTYPE_p_gum__SetT_gum__Edge_t__const_iterator swig_types[111]
#define SWIGTYPE_p_gum__SetT_gum__PotentialT_double_t_const_p_t swig_types[112]
#define SWIGTYPE_p_gum__SetT_std__size_t_t swig_types[113]
#define SWIGTYPE_p_gum__SetT_std__size_t_t__const_iterator swig_types[114]
#define SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t swig_types[115]
#define SWIGTYPE_p_gum__SizeError swig_types[116]
#define SWIGTYPE_p_gum__StructuralComparator swig_types[117]
#define SWIGTYPE_p_gum__SyntaxError swig_types[118]
#define SWIGTYPE_p_gum__Triangulation swig_types[119]
#define SWIGTYPE_p_gum__TypeError swig_types[120]
#define SWIGTYPE_p_gum__UndefinedElement swig_types[121]
#define SWIGTYPE_p_gum__UndefinedIteratorKey swig_types[122]
#define SWIGTYPE_p_gum__UndefinedIteratorValue swig_types[123]
#define SWIGTYPE_p_gum__UndiGraph swig_types[124]
#define SWIGTYPE_p_gum__UnknownLabelInDatabase swig_types[125]
#define SWIGTYPE_p_gum__Variable swig_types[126]
#define SWIGTYPE_p_gum__VariableEliminationT_double_t swig_types[127]
#define SWIGTYPE_p_gum__VariableNodeMap swig_types[128]
#define SWIGTYPE_p_gum__WeightedSamplingT_double_t swig_types[129]
#define SWIGTYPE_p_gum__WrongClassElement swig_types[130]
#define SWIGTYPE_p_gum__WrongType swig_types[131]
#define SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t swig_types[132]
#define SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t swig_types[133]
#define SWIGTYPE_p_gum__credal__CredalNetT_double_t swig_types[134]
#define SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t swig_types[135]
#define SWIGTYPE_p_gum__learning__BNLearnerT_double_t swig_types[136]
#define SWIGTYPE_p_gum__learning__DatabaseTableT_std__allocator_t swig_types[137]
#define SWIGTYPE_p_gum__learning__genericBNLearner swig_types[138]
#define SWIGTYPE_p_iterator_category swig_types[139]
#define SWIGTYPE_p_msg swig_types[140]
#define SWIGTYPE_p_node_const_iterator swig_types[141]
#define SWIGTYPE_p_node_const_iterator_safe swig_types[142]
#define SWIGTYPE_p_node_iterator swig_types[143]
#define SWIGTYPE_p_node_iterator_safe swig_types[144]
#define SWIGTYPE_p_p_PyObject swig_types[145]
#define SWIGTYPE_p_size_type swig_types[146]
#define SWIGTYPE_p_std__allocatorT_double_t swig_types[147]
#define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[148]
#define SWIGTYPE_p_std__allocatorT_unsigned_int_t swig_types[149]
#define SWIGTYPE_p_std__default_random_engine swig_types[150]
#define SWIGTYPE_p_std__functionT_double_fdoubleF_t swig_types[151]
#define SWIGTYPE_p_std__functionT_double_fdouble_doubleF_t swig_types[152]
#define SWIGTYPE_p_std__invalid_argument swig_types[153]
#define SWIGTYPE_p_std__ostream swig_types[154]
#define SWIGTYPE_p_std__size_t swig_types[155]
#define SWIGTYPE_p_std__string swig_types[156]
#define SWIGTYPE_p_std__vectorT_PythonLoadListener_std__allocatorT_PythonLoadListener_t_t swig_types[157]
#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[158]
#define SWIGTYPE_p_std__vectorT_gum__Arc_std__allocatorT_gum__Arc_t_t swig_types[159]
#define SWIGTYPE_p_std__vectorT_gum__DiscreteVariable_const_p_std__allocatorT_gum__DiscreteVariable_const_p_t_t swig_types[160]
#define SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t swig_types[161]
#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[162]
#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[163]
#define SWIGTYPE_p_std__vectorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_std__allocatorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t swig_types[164]
#define SWIGTYPE_p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t swig_types[165]
#define SWIGTYPE_p_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t swig_types[166]
#define SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t swig_types[167]
#define SWIGTYPE_p_swig__SwigPyIterator swig_types[168]
#define SWIGTYPE_p_value_type swig_types[169]
#define SWIGTYPE_p_void swig_types[170]
static swig_type_info *swig_types[172];
static swig_module_info swig_module = {swig_types, 171, 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) -------- */

#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery

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

#else
#  define SWIG_init    init_pyAgrum

#endif
#define SWIG_name    "_pyAgrum"

#define SWIGVERSION 0x040000 
#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 <iostream>

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


#include <typeinfo>
#include <stdexcept>


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


#include <string>


#include <stddef.h>


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;
#if PY_VERSION_HEX < 0x03000000
  } else if (PyInt_Check(obj)) {
    if (val) *val = (double) PyInt_AsLong(obj);
    return SWIG_OK;
#endif
  } 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();
      return SWIG_OverflowError;
    }
  }
#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;
}


#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


#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
#  define SWIG_LONG_LONG_AVAILABLE
#endif


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    unsigned long long v = PyLong_AsUnsignedLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_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;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
      if (val) *val = (unsigned long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    unsigned long long v;
    res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  }
#endif
  return res;
}


  #define SWIG_From_long   PyInt_FromLong 


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_long_SS_long  (long long value)
{
  return ((value < LONG_MIN) || (value > LONG_MAX)) ?
    PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
#endif


SWIGINTERNINLINE PyObject *
SWIG_From_ptrdiff_t  (ptrdiff_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(ptrdiff_t) <= sizeof(long)) {
#endif
    return SWIG_From_long  (static_cast< long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(ptrdiff_t) <= sizeof(long long) */
    return SWIG_From_long_SS_long  (static_cast< long long >(value));
  }
#endif
}


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


SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else
#endif
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#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;
}


#ifdef SWIG_LONG_LONG_AVAILABLE
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();
      res = SWIG_OverflowError;
    }
  } 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))
      return SWIG_OverflowError;
    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;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(ptrdiff_t) <= sizeof(long)) {
#endif
    long v;
    res = SWIG_AsVal_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(ptrdiff_t) <= sizeof(long long)) {
    long long v;
    res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
  }
#endif
  return res;
}


#include <algorithm>


#include <vector>


#define SWIG_FILE_WITH_INIT

#include "extensions/helpers.h"


#define PYGUM_CATCH(GUMEXCEPTION)                                               \
  catch (gum::GUMEXCEPTION & e) {                                               \
     PyErr_SetString (SWIG_Python_ExceptionType(SWIGTYPE_p_gum__##GUMEXCEPTION),e.what().c_str()); \
  }

static void SetPythonizeAgrumException() {
  try {
    throw;
  }
  catch ( std::bad_cast& ) {
    PyErr_SetString ( PyExc_RuntimeError, "C++ Bad Cast" );
  }
  PYGUM_CATCH(DefaultInLabel)
  PYGUM_CATCH(DuplicateElement)
  PYGUM_CATCH(DuplicateLabel)
  PYGUM_CATCH(EmptyBSTree)
  PYGUM_CATCH(EmptySet)
  PYGUM_CATCH(FatalError)
  PYGUM_CATCH(FormatNotFound)
  PYGUM_CATCH(IdError)
  PYGUM_CATCH(InvalidArc)
  PYGUM_CATCH(InvalidArgument)
  PYGUM_CATCH(InvalidArgumentsNumber)
  PYGUM_CATCH(InvalidDirectedCycle)
  PYGUM_CATCH(InvalidEdge)
  PYGUM_CATCH(InvalidNode)
  PYGUM_CATCH(MissingValueInDatabase)
  PYGUM_CATCH(MissingVariableInDatabase)
  PYGUM_CATCH(NoChild)
  PYGUM_CATCH(NoNeighbour)
  PYGUM_CATCH(NoParent)
  PYGUM_CATCH(GraphError)
  PYGUM_CATCH(NotFound)
  PYGUM_CATCH(NullElement)
  PYGUM_CATCH(OperationNotAllowed)
  PYGUM_CATCH(OutOfLowerBound)
  PYGUM_CATCH(OutOfUpperBound)
  PYGUM_CATCH(OutOfBounds)
  PYGUM_CATCH(ReferenceError)
  PYGUM_CATCH(SizeError)
  PYGUM_CATCH(SyntaxError)
  PYGUM_CATCH(IOError)
  PYGUM_CATCH(UndefinedElement)
  PYGUM_CATCH(UndefinedIteratorKey)
  PYGUM_CATCH(UndefinedIteratorValue)
  PYGUM_CATCH(UnknownLabelInDatabase)
  catch ( gum::Exception& e ) {
    PyErr_SetString ( PyExc_Exception, e.what().c_str() );
  }
  catch ( std::exception& e ) {
    PyErr_SetString ( PyExc_Exception, e.what() );
  }
}


#include "extensions/JunctionTreeGenerator.h"


#include "extensions/PythonBNListener.h"
#include "extensions/PythonLoadListener.h"
#include "extensions/PythonApproximationListener.h"
#include "extensions/PythonDatabaseGeneratorListener.h"


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;
}


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


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 defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
  if (PyBytes_Check(obj))
#else
  if (PyUnicode_Check(obj))
#endif
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
    int ret = SWIG_OK;
#if PY_VERSION_HEX>=0x03000000
#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    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);
    if (!obj)
      return SWIG_TypeError;
    if (alloc)
      *alloc = SWIG_NEWOBJ;
#endif
    PyBytes_AsStringAndSize(obj, &cstr, &len);
#else
    PyString_AsStringAndSize(obj, &cstr, &len);
#endif
    if (cptr) {
      if (alloc) {
	if (*alloc == SWIG_NEWOBJ) {
	  *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
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
	*cptr = PyBytes_AsString(obj);
#else
	assert(0); /* Should never reach here with Unicode strings in Python 3 */
#endif
#else
	*cptr = SWIG_Python_str_AsChar(obj);
        if (!*cptr)
          ret = SWIG_TypeError;
#endif
      }
    }
    if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    Py_XDECREF(obj);
#endif
    return ret;
  } else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
    if (PyUnicode_Check(obj)) {
      char *cstr; Py_ssize_t len;
      if (!alloc && cptr) {
        return SWIG_RuntimeError;
      }
      obj = PyUnicode_AsUTF8String(obj);
      if (!obj)
        return SWIG_TypeError;
      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
        if (cptr) {
          if (alloc) *alloc = SWIG_NEWOBJ;
          *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        }
        if (psize) *psize = len + 1;

        Py_XDECREF(obj);
        return SWIG_OK;
      } else {
        Py_XDECREF(obj);
      }
    }
#endif
#endif

    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 "extensions/BNGenerator.h"


#include "extensions/IDGenerator.h"


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;
}


#include "extensions/PRMexplorer.h"


#include <iostream>
#include <iomanip>
#include <string>
#include <ostream>
#include <sstream>
#include <vector>
#include <limits>
#include <utility>
#include <new>
#include <exception>
#include <typeinfo>

#include <agrum/core/types.h>
#include <agrum/core/utils_misc.h>
#include <agrum/core/hashFunc.h>
#include <agrum/core/bijection.h>
#include <agrum/core/set.h>
#include <agrum/core/debug.h>
#include <agrum/core/exceptions.h>
#include <agrum/core/hashTable.h>
#include <agrum/core/refPtr.h>
#include <agrum/core/list.h>
#include <agrum/core/OMPThreads.h>

#include <agrum/graphs/parts/edgeGraphPart.h>
#include <agrum/graphs/parts/arcGraphPart.h>
#include <agrum/graphs/parts/nodeGraphPart.h>

#include <agrum/graphs/diGraph.h>
#include <agrum/graphs/DAG.h>
#include <agrum/graphs/undiGraph.h>
#include <agrum/graphs/mixedGraph.h>
#include <agrum/graphs/cliqueGraph.h>
#include <agrum/graphs/algorithms/triangulations/defaultTriangulation.h>
#include <agrum/variables/discreteVariable.h>
#include <agrum/multidim/implementations/multiDimInterface.h>
#include <agrum/multidim/implementations/multiDimAdressable.h>
#include <agrum/multidim/instantiation.h>
#include <agrum/multidim/implementations/multiDimContainer.h>
#include <agrum/multidim/implementations/multiDimDecorator.h>
#include <agrum/multidim/implementations/multiDimImplementation.h>
#include <agrum/multidim/implementations/multiDimWithOffset.h>
#include <agrum/multidim/implementations/multiDimReadOnly.h>
#include <agrum/multidim/ICIModels/multiDimNoisyORCompound.h>
#include <agrum/multidim/ICIModels/multiDimNoisyAND.h>
#include <agrum/graphicalModels/variableNodeMap.h>

#include <agrum/core/sequence.h>
#include <agrum/variables/variable.h>
#include <agrum/variables/discreteVariable.h>
#include <agrum/variables/labelizedVariable.h>
#include <agrum/variables/rangeVariable.h>
#include <agrum/variables/IDiscretizedVariable.h>
#include <agrum/variables/discretizedVariable.h>
#include <agrum/graphs/graphElements.h>
#include <agrum/multidim/potential.h>
#include <agrum/multidim/implementations/multiDimArray.h>

#include <agrum/BN/IBayesNet.h>
#include <agrum/BN/BayesNet.h>

#include <agrum/BN/algorithms/essentialGraph.h>
#include <agrum/BN/algorithms/MarkovBlanket.h>
#include <agrum/BN/algorithms/structuralComparator.h>

#include <agrum/BN/io/BIF/BIFReader.h>
#include <agrum/BN/io/BIF/BIFWriter.h>
#include <agrum/BN/io/DSL/DSLReader.h>
#include <agrum/BN/io/DSL/DSLWriter.h>
#include <agrum/BN/io/net/netReader.h>
#include <agrum/BN/io/net/netWriter.h>
#include <agrum/BN/io/BIFXML/BIFXMLBNReader.h>
#include <agrum/BN/io/BIFXML/BIFXMLBNWriter.h>
#include <agrum/PRM/o3prm/O3prmBNReader.h>
#include <agrum/PRM/o3prm/O3prmBNWriter.h>
#include <agrum/BN/io/UAI/UAIReader.h>
#include <agrum/BN/io/UAI/UAIWriter.h>

#include <agrum/core/approximations/IApproximationSchemeConfiguration.h>
#include <agrum/core/approximations/approximationScheme.h>

#include <agrum/BN/inference/tools/BayesNetInference.h>

#include <agrum/BN/inference/lazyPropagation.h>
#include <agrum/BN/inference/ShaferShenoyInference.h>
#include <agrum/BN/inference/variableElimination.h>

#include <agrum/BN/inference/GibbsSampling.h>
#include <agrum/BN/inference/importanceSampling.h>
#include <agrum/BN/inference/weightedSampling.h>
#include <agrum/BN/inference/MonteCarloSampling.h>
#include <agrum/BN/inference/loopySamplingInference.h>

#include <agrum/BN/inference/loopyBeliefPropagation.h>

#include <agrum/BN/algorithms/divergence/BNdistance.h>
#include <agrum/BN/algorithms/divergence/exactBNdistance.h>
#include <agrum/BN/algorithms/divergence/GibbsBNdistance.h>

#include <agrum/core/signal/listener.h>
#include <agrum/graphs/parts/listeners/diGraphListener.h>

#include <agrum/CN/credalNet.h>
#include <agrum/CN/varMod2BNsMap.h>
#include <agrum/CN/inferenceEngine.h>
#include <agrum/CN/multipleInferenceEngine.h>
#include <agrum/CN/CNMonteCarloSampling.h>
#include <agrum/CN/CNLoopyPropagation.h>

#include <agrum/learning/database/databaseTable.h>
#include <agrum/learning/BNLearner.h>
#include <agrum/learning/database/BNDatabaseGenerator.h>

#include <agrum/ID/influenceDiagram.h>
#include <agrum/ID/inference/IInfluenceDiagramInference.h>
#include <agrum/ID/inference/influenceDiagramInference.h>
#include <agrum/ID/io/BIFXML/BIFXMLIDReader.h>
#include <agrum/ID/io/BIFXML/BIFXMLIDWriter.h>
#include <agrum/ID/generator/influenceDiagramGenerator.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;
    }
  };

  /*
    Partial specialization for pointers (traits_info)
  */
  template <class Type> struct traits_info<Type *> {
    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 (traits)
  */
  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 = 0;
      swig_type_info *descriptor = type_info<Type>();
      int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
      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) {
      Type v;
      int res = asval(obj, &v);
      if (!obj || !SWIG_IsOK(res)) {
	if (!PyErr_Occurred()) {
	  ::SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	throw std::invalid_argument("bad type");
      }
      return v;
    }
  };

  template <class Type> 
  struct traits_as<Type, pointer_category> {
    static Type as(PyObject *obj) {
      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 {
	if (!PyErr_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	throw std::invalid_argument("bad type");
      }
    }
  };

  template <class Type> 
  struct traits_as<Type*, pointer_category> {
    static Type* as(PyObject *obj) {
      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>());
	}
	throw std::invalid_argument("bad type");
      }
    }
  };
    
  template <class Type>
  inline Type as(PyObject *obj) {
    return traits_as<Type, typename traits<Type>::category>::as(obj);
  }

  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 *>
  {
    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>
  {
    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>
  {
    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, i <= j
      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;
      }
      if (jj < ii)
        jj = ii;
    } else {
      // Required range: -1 <= i < size-1, -1 <= j < size-1, i >= j
      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);
      }
      if (ii < jj)
        ii = jj;
    }
  }

  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>
  inline void
  erase(Sequence* seq, const typename Sequence::iterator& position) {
    seq->erase(position);
  }

  template <class Sequence>
  struct traits_reserve {
    static void reserve(Sequence & /*seq*/, typename Sequence::size_type /*n*/) {
      // This should be specialized for types that support reserve
    }
  };

  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();
        swig::traits_reserve<Sequence>::reserve(*sequence, (jj - ii + step - 1) / step);
        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();
      swig::traits_reserve<Sequence>::reserve(*sequence, (ii - jj - step - 1) / -step);
      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 (step == 1) {
        size_t ssize = jj - ii;
        if (ssize <= is.size()) {
          // expanding/staying the same size
          swig::traits_reserve<Sequence>::reserve(*self, self->size() - ssize + is.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 && it != self->end(); ++rc) {
          *it++ = *isit++;
          for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
            it++;
        }
      }
    } else {
      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 && it != self->rend(); ++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) {
      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 {
      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 SwigPyForwardIteratorOpen_T :  public SwigPyIterator_T<OutIterator>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;
    typedef SwigPyForwardIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyForwardIteratorOpen_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;
    }

  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyIteratorOpen_T :  public SwigPyForwardIteratorOpen_T<OutIterator, ValueType, FromOper>
  {
  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)
      : SwigPyForwardIteratorOpen_T<OutIterator>(curr, seq)
    {
    }

    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 SwigPyForwardIteratorClosed_T :  public SwigPyIterator_T<OutIterator>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;    
    typedef SwigPyForwardIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyForwardIteratorClosed_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;
    }

  protected:
    out_iterator begin;
    out_iterator end;
  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyIteratorClosed_T :  public SwigPyForwardIteratorClosed_T<OutIterator,ValueType,FromOper>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;
    typedef SwigPyForwardIteratorClosed_T<OutIterator, ValueType, FromOper> base0;
    typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
      : SwigPyForwardIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
    {
    }

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


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

  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_forward_iterator(const OutIter& current, PyObject *seq = 0)
  {
    return new SwigPyForwardIteratorOpen_T<OutIter>(current, 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, Py_ssize_t index)
      : _seq(seq), _index(index)
    {
    }
    
    operator T () const
    {
      swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index);
      try {
	return swig::as<T>(item);
      } catch (const std::invalid_argument& e) {
	char msg[1024];
	sprintf(msg, "in sequence element %d ", (int)_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;
    Py_ssize_t _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 Py_ssize_t difference_type;

    SwigPySequence_InputIterator()
    {
    }

    SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t 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;
  };

  // STL container wrapper around a Python sequence
  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 Py_ssize_t difference_type;
    typedef size_t 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
    {
      Py_ssize_t s = size();
      for (Py_ssize_t 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", (int)i);
	    SWIG_Error(SWIG_RuntimeError, msg);
	  }
	  return false;
	}
      }
      return true;
    }

  private:
    PyObject* _seq;
  };

}


  #define SWIG_From_double   PyFloat_FromDouble 


namespace swig {
  template <> struct traits< double > {
    typedef value_category category;
    static const char* type_name() { return"double"; }
  };
  template <>  struct traits_asval< double > {
    typedef double value_type;
    static int asval(PyObject *obj, value_type *val) {
      return SWIG_AsVal_double (obj, val);
    }
  };
  template <>  struct traits_from< double > {
    typedef double value_type;
    static PyObject *from(const value_type& val) {
      return SWIG_From_double  (val);
    }
  };
}


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;
	swig_type_info *descriptor = swig::type_info<sequence>();
	if (descriptor && SWIG_IsOK(::SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
	  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_InternalNewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
      }
#endif
      size_type size = seq.size();
      if (size <= (size_type)INT_MAX) {
	PyObject *obj = PyTuple_New((Py_ssize_t)size);
	Py_ssize_t 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_reserve<std::vector<T> > {
      static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
        seq.reserve(n);
      }
    };

    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< double, std::allocator< double > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "double" "," "std::allocator< double >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
      return self->size();
    }

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


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
#endif


SWIGINTERNINLINE PyObject *
SWIG_From_size_t  (size_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(size_t) <= sizeof(unsigned long long) */
    return SWIG_From_unsigned_SS_long_SS_long  (static_cast< unsigned long long >(value));
  }
#endif
}

SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
    }
SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *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< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > 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< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *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< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *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< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< double,std::allocator< double > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }

SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UINT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned int >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE PyObject*
  SWIG_From_unsigned_SS_int  (unsigned int value)
{
  return PyInt_FromSize_t((size_t) value);
}


namespace swig {
  template <> struct traits< unsigned int > {
    typedef value_category category;
    static const char* type_name() { return"unsigned int"; }
  };
  template <>  struct traits_asval< unsigned int > {
    typedef unsigned int value_type;
    static int asval(PyObject *obj, value_type *val) {
      return SWIG_AsVal_unsigned_SS_int (obj, val);
    }
  };
  template <>  struct traits_from< unsigned int > {
    typedef unsigned int value_type;
    static PyObject *from(const value_type& val) {
      return SWIG_From_unsigned_SS_int  (val);
    }
  };
}


      namespace swig {
	template <>  struct traits<std::vector< unsigned int, std::allocator< unsigned int > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "unsigned int" "," "std::allocator< unsigned int >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_unsigned_SS_int_Sg__iterator(std::vector< unsigned int > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg____nonzero__(std::vector< unsigned int > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg____bool__(std::vector< unsigned int > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< unsigned int >::size_type std_vector_Sl_unsigned_SS_int_Sg____len__(std::vector< unsigned int > const *self){
      return self->size();
    }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > *std_vector_Sl_unsigned_SS_int_Sg____getslice__(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i,std::vector< unsigned int >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setslice____SWIG_0(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i,std::vector< unsigned int >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< unsigned int,std::allocator< unsigned int > >());
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setslice____SWIG_1(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i,std::vector< unsigned int >::difference_type j,std::vector< unsigned int,std::allocator< unsigned int > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____delslice__(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i,std::vector< unsigned int >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____delitem____SWIG_0(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > *std_vector_Sl_unsigned_SS_int_Sg____getitem____SWIG_0(std::vector< unsigned int > *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< unsigned int,std::allocator< unsigned int > >::difference_type id = i;
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_0(std::vector< unsigned int > *self,PySliceObject *slice,std::vector< unsigned int,std::allocator< unsigned int > > 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< unsigned int,std::allocator< unsigned int > >::difference_type id = i;
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_1(std::vector< unsigned int > *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< unsigned int,std::allocator< unsigned int > >::difference_type id = i;
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____delitem____SWIG_1(std::vector< unsigned int > *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< unsigned int,std::allocator< unsigned int > >::difference_type id = i;
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< unsigned int >::value_type const &std_vector_Sl_unsigned_SS_int_Sg____getitem____SWIG_1(std::vector< unsigned int > const *self,std::vector< unsigned int >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_2(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i,std::vector< unsigned int >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< unsigned int >::value_type std_vector_Sl_unsigned_SS_int_Sg__pop(std::vector< unsigned int > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< unsigned int,std::allocator< unsigned int > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__append(std::vector< unsigned int > *self,std::vector< unsigned int >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< unsigned int >::iterator std_vector_Sl_unsigned_SS_int_Sg__erase__SWIG_0(std::vector< unsigned int > *self,std::vector< unsigned int >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< unsigned int >::iterator std_vector_Sl_unsigned_SS_int_Sg__erase__SWIG_1(std::vector< unsigned int > *self,std::vector< unsigned int >::iterator first,std::vector< unsigned int >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< unsigned int >::iterator std_vector_Sl_unsigned_SS_int_Sg__insert__SWIG_0(std::vector< unsigned int > *self,std::vector< unsigned int >::iterator pos,std::vector< unsigned int >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__insert__SWIG_1(std::vector< unsigned int > *self,std::vector< unsigned int >::iterator pos,std::vector< unsigned int >::size_type n,std::vector< unsigned int >::value_type const &x){ self->insert(pos, n, x); }

SWIGINTERN int
SWIG_AsVal_std_string (PyObject * obj, std::string *val)
{
  std::string* v = (std::string *) 0;
  int res = SWIG_AsPtr_std_string (obj, &v);
  if (!SWIG_IsOK(res)) return res;
  if (v) {
    if (val) *val = *v;
    if (SWIG_IsNewObj(res)) {
      delete v;
      res = SWIG_DelNewMask(res);
    }
    return res;
  }
  return SWIG_ERROR;
}


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 defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
      return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#else
      return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
#endif
#else
      return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


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


namespace swig {
  template <> struct traits< std::string > {
    typedef value_category category;
    static const char* type_name() { return"std::string"; }
  };
  template <>  struct traits_asval< std::string > {
    typedef std::string value_type;
    static int asval(PyObject *obj, value_type *val) {
      return SWIG_AsVal_std_string (obj, val);
    }
  };
  template <>  struct traits_from< std::string > {
    typedef std::string value_type;
    static PyObject *from(const value_type& val) {
      return SWIG_From_std_string  (val);
    }
  };
}


      namespace swig {
	template <>  struct traits<std::vector< std::string, std::allocator< std::string > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::string" "," "std::allocator< std::string >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_string_Sg__iterator(std::vector< std::string > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_string_Sg____nonzero__(std::vector< std::string > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_string_Sg____bool__(std::vector< std::string > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::string >::size_type std_vector_Sl_std_string_Sg____len__(std::vector< std::string > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::string,std::allocator< std::string > >());
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_1(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j,std::vector< std::string,std::allocator< std::string > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *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< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > 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< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *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< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *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< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_string_Sg____getitem____SWIG_1(std::vector< std::string > const *self,std::vector< std::string >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_2(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::string,std::allocator< std::string > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_string_Sg__append(std::vector< std::string > *self,std::vector< std::string >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator first,std::vector< std::string >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__insert__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_string_Sg__insert__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::size_type n,std::vector< std::string >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN std::string gum_DiscreteVariable___repr__(gum::DiscreteVariable const *self){
   std::stringstream s;
   s<<"(gum::DiscreteVariable@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_DiscreteVariable___str__(gum::DiscreteVariable const *self){ return self->toString();}
SWIGINTERN gum::LabelizedVariable gum_DiscreteVariable_toLabelizedVar(gum::DiscreteVariable *self){
    return gum::LabelizedVariable(* dynamic_cast<gum::LabelizedVariable*>(self ));
  }
SWIGINTERN gum::RangeVariable gum_DiscreteVariable_toRangeVar(gum::DiscreteVariable *self){
    return gum::RangeVariable(* dynamic_cast<gum::RangeVariable*>(self ));
  }
SWIGINTERN gum::DiscretizedVariable< double > gum_DiscreteVariable_toDiscretizedVar(gum::DiscreteVariable *self){
    return gum::DiscretizedVariable<double>(* dynamic_cast<gum::DiscretizedVariable<double> *> (self ));
  }
SWIGINTERN std::string gum_LabelizedVariable___repr__(gum::LabelizedVariable const *self){
   std::stringstream s;
   s<<"(gum::LabelizedVariable@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_LabelizedVariable___str__(gum::LabelizedVariable const *self){ return self->toString();}
SWIGINTERN std::string gum_RangeVariable___repr__(gum::RangeVariable const *self){
   std::stringstream s;
   s<<"(gum::RangeVariable@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_RangeVariable___str__(gum::RangeVariable const *self){ return self->toString();}
SWIGINTERN std::string gum_UndiGraph___repr__(gum::UndiGraph const *self){
   std::stringstream s;
   s<<"(gum::UndiGraph@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_UndiGraph___str__(gum::UndiGraph const *self){ return self->toString();}
SWIGINTERN PyObject *gum_UndiGraph_nodes(gum::UndiGraph const *self){
    return PyAgrumHelper::PySetFromNodeSet(self->nodes());
    PyObject* q=PyList_New(0);

    for ( auto node : self->nodes()) {
      PyList_Append(q,PyInt_FromLong(node));
    }

    return q;
  }
SWIGINTERN PyObject *gum_UndiGraph_addNodes(gum::UndiGraph const *self,gum::Size n){
    PyObject* q=PySet_New(0);

    for(auto node : const_cast<gum::UndiGraph *>(self)->addNodes(n)) {
          PySet_Add(q,PyInt_FromLong(node));
        }

    return q;
  }
SWIGINTERN PyObject *gum_UndiGraph_edges(gum::UndiGraph *self){ // add for the sub-classes (including MixedGraph)
    return PyAgrumHelper::PySetFromEdgeSet(self->edges());
  }
SWIGINTERN PyObject *gum_UndiGraph_neighbours(gum::UndiGraph *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->neighbours(id));
  }
SWIGINTERN gum::NodeId gum_UndiGraph_addNode(gum::UndiGraph *self){
    return self->gum::NodeGraphPart::addNode();
  }
SWIGINTERN void gum_UndiGraph_addNodeWithId(gum::UndiGraph *self,gum::NodeId const id){
    self->gum::NodeGraphPart::addNodeWithId(id);
  }
SWIGINTERN bool gum_UndiGraph_existsNode(gum::UndiGraph const *self,gum::NodeId const id){
    return self->gum::NodeGraphPart::existsNode(id);
  }
SWIGINTERN gum::Size gum_UndiGraph_size(gum::UndiGraph const *self){
    return self->gum::NodeGraphPart::size();
  }
SWIGINTERN bool gum_UndiGraph_empty(gum::UndiGraph const *self){
    return self->gum::NodeGraphPart::empty();
  }
SWIGINTERN void gum_UndiGraph_addEdge(gum::UndiGraph *self,gum::NodeId const n1,gum::NodeId const n2){
    self->gum::EdgeGraphPart::addEdge(n1,n2);
  }
SWIGINTERN void gum_UndiGraph_eraseEdge(gum::UndiGraph *self,gum::NodeId const n1,gum::NodeId const n2){
    self->gum::EdgeGraphPart::eraseEdge(gum::Edge(n1,n2));
  }
SWIGINTERN bool gum_UndiGraph_existsEdge(gum::UndiGraph const *self,gum::NodeId const n1,gum::NodeId const n2){
    return self->gum::EdgeGraphPart::existsEdge(n1,n2);
  }
SWIGINTERN gum::Size gum_UndiGraph_sizeEdges(gum::UndiGraph const *self){
    return self->gum::EdgeGraphPart::sizeEdges();
  }
SWIGINTERN bool gum_UndiGraph_emptyEdges(gum::UndiGraph const *self){
    return self->gum::EdgeGraphPart::emptyEdges();
  }
SWIGINTERN void gum_UndiGraph_eraseNeighbours(gum::UndiGraph *self,gum::NodeId const n){
    self->gum::EdgeGraphPart::eraseNeighbours(n);
  }
SWIGINTERN std::string gum_DiGraph___repr__(gum::DiGraph const *self){
   std::stringstream s;
   s<<"(gum::DiGraph@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_DiGraph___str__(gum::DiGraph const *self){ return self->toString();}
SWIGINTERN PyObject *gum_DiGraph_nodes(gum::DiGraph const *self){
    return PyAgrumHelper::PySetFromNodeSet(self->nodes());
    PyObject* q=PyList_New(0);

    for ( auto node : self->nodes()) {
      PyList_Append(q,PyInt_FromLong(node));
    }

    return q;
  }
SWIGINTERN PyObject *gum_DiGraph_addNodes(gum::DiGraph const *self,gum::Size n){
    PyObject* q=PySet_New(0);

    for(auto node : const_cast<gum::DiGraph *>(self)->addNodes(n)) {
          PySet_Add(q,PyInt_FromLong(node));
        }

    return q;
  }
SWIGINTERN PyObject *gum_DiGraph_arcs(gum::DiGraph const *self){ // add for the sub-classes (including MixedGraph)
    return PyAgrumHelper::PySetFromArcSet(self->arcs());
  }
SWIGINTERN PyObject *gum_DiGraph_parents(gum::DiGraph *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->parents(id));
  }
SWIGINTERN PyObject *gum_DiGraph_children(gum::DiGraph *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->children(id));
  }
SWIGINTERN gum::NodeId gum_DiGraph_addNode(gum::DiGraph *self){
    return self->gum::NodeGraphPart::addNode();
  }
SWIGINTERN void gum_DiGraph_addNodeWithId(gum::DiGraph *self,gum::NodeId const id){
    self->gum::NodeGraphPart::addNodeWithId(id);
  }
SWIGINTERN bool gum_DiGraph_existsNode(gum::DiGraph const *self,gum::NodeId const id){
    return self->gum::NodeGraphPart::existsNode(id);
  }
SWIGINTERN gum::Size gum_DiGraph_size(gum::DiGraph const *self){
    return self->gum::NodeGraphPart::size();
  }
SWIGINTERN bool gum_DiGraph_empty(gum::DiGraph const *self){
    return self->gum::NodeGraphPart::empty();
  }
SWIGINTERN void gum_DiGraph_addArc__SWIG_1(gum::DiGraph *self,gum::NodeId const n1,gum::NodeId const n2){
    self->gum::ArcGraphPart::addArc(n1,n2);
  }
SWIGINTERN void gum_DiGraph_eraseArc(gum::DiGraph *self,gum::NodeId const n1,gum::NodeId const n2){
    self->gum::ArcGraphPart::eraseArc(gum::Arc(n1,n2));
  }
SWIGINTERN bool gum_DiGraph_existsArc(gum::DiGraph const *self,gum::NodeId const n1,gum::NodeId const n2){
    return self->gum::ArcGraphPart::existsArc(n1,n2);
  }
SWIGINTERN void gum_DiGraph_eraseParents(gum::DiGraph *self,gum::NodeId const n){
    self->gum::ArcGraphPart::eraseParents(n);
  }
SWIGINTERN void gum_DiGraph_eraseChildren(gum::DiGraph *self,gum::NodeId const n){
    self->gum::ArcGraphPart::eraseChildren(n);
  }
SWIGINTERN gum::Size gum_DiGraph_sizeArcs(gum::DiGraph const *self){
    return self->gum::ArcGraphPart::sizeArcs();
  }
SWIGINTERN bool gum_DiGraph_emptyArcs(gum::DiGraph const *self){
    return self->gum::ArcGraphPart::emptyArcs();
  }
SWIGINTERN PyObject *gum_DAG_addNodes(gum::DAG const *self,gum::Size n){
    PyObject* q=PySet_New(0);

    for(auto node : const_cast<gum::DAG *>(self)->addNodes(n)) {
          PySet_Add(q,PyInt_FromLong(node));
        }

    return q;
  }
SWIGINTERN void gum_DAG_addArc__SWIG_1(gum::DAG *self,gum::NodeId const n1,gum::NodeId const n2){
    self->gum::ArcGraphPart::addArc(n1,n2);
  }
SWIGINTERN std::string gum_MixedGraph___repr__(gum::MixedGraph const *self){
   std::stringstream s;
   s<<"(gum::MixedGraph@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_MixedGraph___str__(gum::MixedGraph const *self){ return self->toString();}
SWIGINTERN PyObject *gum_CliqueGraph_clique(gum::CliqueGraph const *self,gum::NodeId const clique){
    PyObject* q=PySet_New(0);

    for(auto node : self->clique(clique)) {
          PySet_Add(q,PyInt_FromLong(node));
        }

    return q;
  }
SWIGINTERN PyObject *gum_CliqueGraph_separator(gum::CliqueGraph const *self,gum::NodeId const cliq1,gum::NodeId const cliq2){
    PyObject* q=PySet_New(0);

    for(auto node : self->separator(cliq1,cliq2)) {
          PySet_Add(q,PyInt_FromLong(node));
        }

    return q;
  }
SWIGINTERN std::string gum_Instantiation___repr__(gum::Instantiation const *self){
   std::stringstream s;
   s<<"(gum::Instantiation@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_Instantiation___str__(gum::Instantiation const *self){ return self->toString();}
SWIGINTERN PyObject *gum_Instantiation_todict__SWIG_0(gum::Instantiation const *self,bool withLabels=false){
    auto res=PyDict_New();
    for(gum::Idx i=0;i<self->nbrDim();i++) {
      auto key=PyString_FromString(self->variable(i).name().c_str());
      PyObject* val;
      if (withLabels) {
        val=PyString_FromString(self->variable(i).label(self->val(i)).c_str());
      } else {
        val=PyLong_FromUnsignedLong(self->val(i));
      }
      PyDict_SetItem(res,key,val);
    }
    return res;
  }
SWIGINTERN void gum_Instantiation_fromdict(gum::Instantiation *self,PyObject *dict){
    if (!PyDict_Check(dict)) {
      GUM_ERROR(gum::InvalidArgument, "Argument is not a dictionary");
    }

    gum::HashTable< std::string, const gum::DiscreteVariable* > namesToVars;
    for (gum::Idx i = 0; i < self->nbrDim(); i++)
      namesToVars.insert(self->variable(i).name(), &(self->variable(i)));

    PyObject *key, *value;
    Py_ssize_t pos = 0;
    while (PyDict_Next(dict, &pos, &key, &value)) {
      std::string name = PyAgrumHelper::stringFromPyObject(key);
      gum::Idx    v;
      if (name == "") {
        GUM_ERROR(gum::InvalidArgument, "A key is not a string");
      }
      if (namesToVars.exists(name)) {
        if (!PyInt_Check(value)) {
          std::string label = PyAgrumHelper::stringFromPyObject(value);
          if (label == "") {
            GUM_ERROR(gum::InvalidArgument,
                      "A value is neither an int or a string");
          }
          v = namesToVars[name]->index(label);  // may throw gum::OutOfBounds
        } else {
          v = gum::Idx(PyInt_AsLong(value));
        }
        if (v >= namesToVars[name]->domainSize()) {
          GUM_ERROR(gum::InvalidArgument,
                    "The value " << v << " is not in the domain of " << name);
        }
        self->chgVal(namesToVars[name], v);
      }
    }
  }
SWIGINTERN PyObject *gum_EssentialGraph_nodes(gum::EssentialGraph const *self){
    return PyAgrumHelper::PySetFromNodeSet(self->nodes());
    PyObject* q=PyList_New(0);

    for ( auto node : self->nodes()) {
      PyList_Append(q,PyInt_FromLong(node));
    }

    return q;
  }
SWIGINTERN PyObject *gum_EssentialGraph_arcs(gum::EssentialGraph const *self){ // add for the sub-classes (including MixedGraph)
    return PyAgrumHelper::PySetFromArcSet(self->arcs());
  }
SWIGINTERN PyObject *gum_EssentialGraph_parents(gum::EssentialGraph *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->parents(id));
  }
SWIGINTERN PyObject *gum_EssentialGraph_children(gum::EssentialGraph *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->children(id));
  }
SWIGINTERN PyObject *gum_EssentialGraph_edges(gum::EssentialGraph *self){ // add for the sub-classes (including MixedGraph)
    return PyAgrumHelper::PySetFromEdgeSet(self->edges());
  }
SWIGINTERN PyObject *gum_EssentialGraph_neighbours(gum::EssentialGraph *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->neighbours(id));
  }
SWIGINTERN PyObject *gum_MarkovBlanket_nodes(gum::MarkovBlanket const *self){
    return PyAgrumHelper::PySetFromNodeSet(self->nodes());
    PyObject* q=PyList_New(0);

    for ( auto node : self->nodes()) {
      PyList_Append(q,PyInt_FromLong(node));
    }

    return q;
  }
SWIGINTERN PyObject *gum_MarkovBlanket_arcs(gum::MarkovBlanket const *self){ // add for the sub-classes (including MixedGraph)
    return PyAgrumHelper::PySetFromArcSet(self->arcs());
  }
SWIGINTERN PyObject *gum_MarkovBlanket_parents(gum::MarkovBlanket *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->parents(id));
  }
SWIGINTERN PyObject *gum_MarkovBlanket_children(gum::MarkovBlanket *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->children(id));
  }
SWIGINTERN std::string gum_DiscretizedVariable_Sl_double_Sg____repr__(gum::DiscretizedVariable< double > const *self){
   std::stringstream s;
   s<<"(gum::DiscretizedVariable<double>@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_DiscretizedVariable_Sl_double_Sg____str__(gum::DiscretizedVariable< double > const *self){ return self->toString();}
SWIGINTERN std::string gum_Potential_Sl_double_Sg____repr__(gum::Potential< double > const *self){
   std::stringstream s;
   s<<"(gum::Potential<double>@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_Potential_Sl_double_Sg____str__(gum::Potential< double > const *self){ return self->toString();}
SWIGINTERN gum::Potential< double > gum_Potential_Sl_double_Sg__extract__SWIG_1(gum::Potential< double > *self,PyObject *dict){
      gum::Instantiation inst;
      PyAgrumHelper::fillInstantiationFromPyObject(self,inst,dict);
      return self->extract(inst);
    }
SWIGINTERN gum::Potential< double > gum_Potential_Sl_double_Sg__reorganize__SWIG_1(gum::Potential< double > const *self,PyObject *varnames){
      std::vector<const gum::DiscreteVariable*> v;
      PyAgrumHelper::fillDVVectorFromPyObject(self,v,varnames); //from helpers.h
      return self->reorganize(v);
    }
SWIGINTERN gum::Potential< double > gum_Potential_Sl_double_Sg__putFirst(gum::Potential< double > const *self,PyObject *varname){
      const gum::DiscreteVariable* v;
      PyAgrumHelper::fillDVFromPyObject(self,v,varname); //from helpers.h
      return self->putFirst(v);
    }
SWIGINTERN gum::Potential< double > gum_Potential_Sl_double_Sg__margSumOut(gum::Potential< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->margSumOut(s);
    }
SWIGINTERN gum::Potential< double > gum_Potential_Sl_double_Sg__margProdOut(gum::Potential< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->margProdOut(s);
    }
SWIGINTERN gum::Potential< double > gum_Potential_Sl_double_Sg__margMaxOut(gum::Potential< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->margMaxOut(s);
    }
SWIGINTERN gum::Potential< double > gum_Potential_Sl_double_Sg__margMinOut(gum::Potential< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->margMinOut(s);
    }
SWIGINTERN gum::Potential< double > gum_Potential_Sl_double_Sg__margSumIn(gum::Potential< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->margSumIn(s);
    }
SWIGINTERN gum::Potential< double > gum_Potential_Sl_double_Sg__margProdIn(gum::Potential< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->margProdIn(s);
    }
SWIGINTERN gum::Potential< double > gum_Potential_Sl_double_Sg__margMaxIn(gum::Potential< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->margMaxIn(s);
    }
SWIGINTERN gum::Potential< double > gum_Potential_Sl_double_Sg__margMinIn(gum::Potential< double > const *self,PyObject *varnames){
      gum::Set<const gum::DiscreteVariable*> s;
      PyAgrumHelper::fillDVSetFromPyObject(self,s,varnames); //from helpers.h
      return self->margMinIn(s);
    }
SWIGINTERN gum::Potential< double > gum_Potential_Sl_double_Sg____truediv____SWIG_1(gum::Potential< double > *self,gum::Potential< double > const &b){
      return *self /b;
    }
SWIGINTERN gum::Potential< double > gum_Potential_Sl_double_Sg____div__(gum::Potential< double > *self,gum::Potential< double > const &b){
      return *self/b;
    }
SWIGINTERN bool gum_Potential_Sl_double_Sg____eq____SWIG_1(gum::Potential< double > *self,gum::Potential< double > const &b){
      return *self==b;
    }
SWIGINTERN bool gum_Potential_Sl_double_Sg____ne____SWIG_1(gum::Potential< double > *self,gum::Potential< double > const &b){
      return *self!=b;
    }
SWIGINTERN void gum_Potential_Sl_double_Sg____fill_distrib__(gum::Potential< double > *self){}
SWIGINTERN PyObject *gum_Potential_Sl_double_Sg____indexfromdict__(gum::Potential< double > *self,PyObject *id_dict){ return NULL; }
SWIGINTERN PyObject *gum_Potential_Sl_double_Sg__tolist(gum::Potential< double > *self){ return NULL; }
SWIGINTERN PyObject *gum_Potential_Sl_double_Sg__toarray(gum::Potential< double > *self){ return NULL; }
SWIGINTERN void gum_Potential_Sl_double_Sg____getitem__(gum::Potential< double > *self,PyObject *id){}
SWIGINTERN void gum_Potential_Sl_double_Sg____setitem__(gum::Potential< double > *self,PyObject *id,PyObject *value){}
SWIGINTERN void gum_Potential_Sl_double_Sg__var_names(gum::Potential< double > *self){}
SWIGINTERN void gum_Potential_Sl_double_Sg__var_dims(gum::Potential< double > *self){}
SWIGINTERN double gum_Potential_Sl_double_Sg__get(gum::Potential< double > const *self,gum::Instantiation const &i){
    return self->gum::MultiDimDecorator<double>::get(i);
  }
SWIGINTERN void gum_Potential_Sl_double_Sg__set(gum::Potential< double > const *self,gum::Instantiation const &i,double const &value){
    self->gum::MultiDimDecorator<double>::set(i,value);
  }
SWIGINTERN bool gum_Potential_Sl_double_Sg__empty(gum::Potential< double > const *self){
    return self->gum::MultiDimDecorator<double>::empty();
  }
SWIGINTERN gum::Idx gum_Potential_Sl_double_Sg__pos(gum::Potential< double > const *self,gum::DiscreteVariable const &v){
    return self->gum::MultiDimDecorator<double>::pos(v);
  }
SWIGINTERN bool gum_Potential_Sl_double_Sg__contains(gum::Potential< double > const *self,gum::DiscreteVariable const &v){
    return self->gum::MultiDimDecorator<double>::contains(v);
  }
SWIGINTERN gum::Idx gum_Potential_Sl_double_Sg__nbrDim(gum::Potential< double > const *self){
    return self->gum::MultiDimDecorator<double>::nbrDim();
  }
SWIGINTERN gum::DiscreteVariable const &gum_Potential_Sl_double_Sg__variable__SWIG_0(gum::Potential< double > const *self,gum::Idx i){
    return self->gum::MultiDimDecorator<double>::variable(i);
  }
SWIGINTERN gum::DiscreteVariable const &gum_Potential_Sl_double_Sg__variable__SWIG_1(gum::Potential< double > const *self,std::string const &name){
    return self->gum::MultiDimDecorator<double>::variable(name);
  }
SWIGINTERN void gum_Potential_Sl_double_Sg__remove(gum::Potential< double > *self,gum::DiscreteVariable const &var){
    self->erase(var);
  }
SWIGINTERN void gum_Potential_Sl_double_Sg__add(gum::Potential< double > *self,gum::DiscreteVariable const &v){
    self->gum::MultiDimDecorator<double>::add(v);
  }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__nodes(gum::IBayesNet< double > const *self){
    return PyAgrumHelper::PySetFromNodeSet(self->nodes());
    PyObject* q=PyList_New(0);

    for ( auto node : self->nodes()) {
      PyList_Append(q,PyInt_FromLong(node));
    }

    return q;
  }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__names(gum::IBayesNet< double > const *self){
    PyObject* q=PyList_New(0);

    for ( auto node : self->dag().nodes()) {
      PyList_Append(q,PyString_FromString(self->variable(node).name().c_str()));
    }
    return q;
  }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__minimalCondSet__SWIG_2(gum::IBayesNet< double > const *self,gum::NodeId target,PyObject *list){
    gum::NodeSet soids;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soids,list,*self);
    return PyAgrumHelper::PySetFromNodeSet(self->minimalCondSet(target, soids));
  }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__minimalCondSet__SWIG_3(gum::IBayesNet< double > const *self,PyObject *targets,PyObject *list){
    gum::NodeSet sotargets;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sotargets,targets,*self);

    gum::NodeSet soids;
    PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soids,list,*self);
    return PyAgrumHelper::PySetFromNodeSet(self->minimalCondSet(sotargets, soids));
  }
SWIGINTERN std::string gum_IBayesNet_Sl_double_Sg____repr__(gum::IBayesNet< double > const *self){
   std::stringstream s;
   s<<"(gum::IBayesNet<double>@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_IBayesNet_Sl_double_Sg____str__(gum::IBayesNet< double > const *self){ return self->toString();}
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__arcs(gum::IBayesNet< double > const *self){ // add for the sub-classes (including MixedGraph)
    return PyAgrumHelper::PySetFromArcSet(self->arcs());
  }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__parents(gum::IBayesNet< double > *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->parents(id));
  }
SWIGINTERN PyObject *gum_IBayesNet_Sl_double_Sg__children(gum::IBayesNet< double > *self,gum::NodeId id){
    return PyAgrumHelper::PySetFromNodeSet(self->children(id));
  }
SWIGINTERN PyObject *gum_BayesNet_Sl_double_Sg__nodes(gum::BayesNet< double > const *self){
    return PyAgrumHelper::PySetFromNodeSet(self->nodes());
    PyObject* q=PyList_New(0);

    for ( auto node : self->nodes()) {
      PyList_Append(q,PyInt_FromLong(node));
    }

    return q;
  }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg__loadBIF__SWIG_0(gum::BayesNet< double > *self,std::string name,PyObject *l=(PyObject *) 0){
      std::stringstream stream;
      std::vector<PythonLoadListener> py_listener;

      try {
          gum::BIFReader<double> reader(self,name);
          int l_size=__fillLoadListeners(py_listener,l);
          for(int i=0 ; i<l_size ; i++) {
              GUM_CONNECT(reader.scanner(), onLoad, py_listener[i], PythonLoadListener::whenLoading);
          }

          auto nbErr=reader.proceed();
          reader.showElegantErrorsAndWarnings(stream);
          if (nbErr>0) {
              reader.showErrorCounts(stream);
              GUM_ERROR(gum::FatalError,stream.str());
          } else {
              return stream.str();
          }
      } catch (gum::IOError& e) {
        throw(e);
      }
      return "";
  }
SWIGINTERN void gum_BayesNet_Sl_double_Sg__saveBIF(gum::BayesNet< double > *self,std::string name){
      gum::BIFWriter<double> writer;
      writer.write( name, *self );
  }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg__loadDSL__SWIG_0(gum::BayesNet< double > *self,std::string name,PyObject *l=(PyObject *) 0){
      std::stringstream stream;
      std::vector<PythonLoadListener> py_listener;

      try {
          gum::DSLReader<double> reader(self,name);
          int l_size=__fillLoadListeners(py_listener,l);
          for(int i=0 ; i<l_size ; i++) {
              GUM_CONNECT(reader.scanner(), onLoad, py_listener[i], PythonLoadListener::whenLoading);
          }

          auto nbErr=reader.proceed();
          reader.showElegantErrorsAndWarnings(stream);
          if (nbErr>0) {
              reader.showErrorCounts(stream);
              GUM_ERROR(gum::FatalError,stream.str());
          } else {
              return stream.str();
          }
      } catch (gum::IOError& e) {
        throw(e);
      }
      return "";
  }
SWIGINTERN void gum_BayesNet_Sl_double_Sg__saveDSL(gum::BayesNet< double > *self,std::string name){
      gum::DSLWriter<double> writer;
      writer.write( name, *self );
  }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg__loadNET__SWIG_0(gum::BayesNet< double > *self,std::string name,PyObject *l=(PyObject *) 0){
      std::stringstream stream;
      std::vector<PythonLoadListener> py_listener;

      try {
          gum::NetReader<double> reader(self,name);
          int l_size=__fillLoadListeners(py_listener,l);
          for(int i=0 ; i<l_size ; i++) {
              GUM_CONNECT(reader.scanner(), onLoad, py_listener[i], PythonLoadListener::whenLoading);
          }

          auto nbErr=reader.proceed();
          reader.showElegantErrorsAndWarnings(stream);
          if (nbErr>0) {
              reader.showErrorCounts(stream);
              GUM_ERROR(gum::FatalError,stream.str());
          } else {
              return stream.str();
          }
      } catch (gum::IOError& e) {
        throw(e);
      }
      return "";
  }
SWIGINTERN void gum_BayesNet_Sl_double_Sg__saveNET(gum::BayesNet< double > *self,std::string name){
      gum::NetWriter<double> writer;
      writer.write( name, *self );
  }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg__loadO3PRM__SWIG_0(gum::BayesNet< double > *self,std::string name,std::string system="",std::string classpath="",PyObject *l=(PyObject *) 0){
      std::stringstream stream;
      std::vector<PythonLoadListener> py_listener;

      try {
          gum::O3prmBNReader<double> reader(self,name,system,classpath);

          auto nbErr=reader.proceed();
          reader.showElegantErrorsAndWarnings(stream);
          if (nbErr>0) {
              reader.showErrorCounts(stream);
              GUM_ERROR(gum::FatalError,stream.str());
          } else {
              return stream.str();
          }
      } catch (gum::IOError& e) {
        throw(e);
      }
      return "";
  }
SWIGINTERN void gum_BayesNet_Sl_double_Sg__saveO3PRM(gum::BayesNet< double > *self,std::string name){
      gum::O3prmBNWriter<double> writer;
      writer.write( name, *self );
  }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg__loadBIFXML__SWIG_0(gum::BayesNet< double > *self,std::string name,PyObject *l=(PyObject *) 0){
      std::stringstream stream;
      std::vector<PythonLoadListener> py_listener;

      try {
          gum::BIFXMLBNReader<double> reader(self,name);

          int isOK=reader.proceed();// for BIFXML, proceed() returns 0 or 1
          if (isOK==1) {
              GUM_ERROR(gum::FatalError,"Errors found in XML file");
          } else {
              return "";
          }
      } catch (gum::IOError& e) {
        throw(e);
      }
      return "";
  }
SWIGINTERN void gum_BayesNet_Sl_double_Sg__saveBIFXML(gum::BayesNet< double > *self,std::string name){
      gum::BIFXMLBNWriter<double> writer;
      writer.write( name, *self );
  }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg__loadUAI__SWIG_0(gum::BayesNet< double > *self,std::string name,PyObject *l=(PyObject *) 0){
      std::stringstream stream;
      std::vector<PythonLoadListener> py_listener;

      try {
          gum::UAIReader<double> reader(self,name);
          int l_size=__fillLoadListeners(py_listener,l);
          for(int i=0 ; i<l_size ; i++) {
              GUM_CONNECT(reader.scanner(), onLoad, py_listener[i], PythonLoadListener::whenLoading);
          }

          auto nbErr=reader.proceed();
          reader.showElegantErrorsAndWarnings(stream);
          if (nbErr>0) {
              reader.showErrorCounts(stream);
              GUM_ERROR(gum::FatalError,stream.str());
          } else {
              return stream.str();
          }
      } catch (gum::IOError& e) {
        throw(e);
      }
      return "";
  }
SWIGINTERN void gum_BayesNet_Sl_double_Sg__saveUAI(gum::BayesNet< double > *self,std::string name){
      gum::UAIWriter<double> writer;
      writer.write( name, *self );
  }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg____repr__(gum::BayesNet< double > const *self){
   std::stringstream s;
   s<<"(gum::BayesNet<double>@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_BayesNet_Sl_double_Sg____str__(gum::BayesNet< double > const *self){ return self->toString();}
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__setEvidence(gum::LazyPropagation< double > *self,PyObject *evidces){}
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__updateEvidence(gum::LazyPropagation< double > *self,PyObject *evidces){}
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__setTargets(gum::LazyPropagation< double > *self,PyObject *targets){}
SWIGINTERN PyObject *gum_LazyPropagation_Sl_double_Sg__hardEvidenceNodes(gum::LazyPropagation< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_LazyPropagation_Sl_double_Sg__softEvidenceNodes(gum::LazyPropagation< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_LazyPropagation_Sl_double_Sg__targets(gum::LazyPropagation< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->targets() );
    }
SWIGINTERN gum::Potential< double > gum_LazyPropagation_Sl_double_Sg__evidenceImpact__SWIG_0(gum::LazyPropagation< double > *self,gum::NodeId target,PyObject *evs){
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN());
      return self->evidenceImpact(target,soe);
    }
SWIGINTERN double gum_LazyPropagation_Sl_double_Sg__jointMutualInformation(gum::LazyPropagation< double > *self,PyObject *targets){
      gum::NodeSet sot;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sot,targets,self->BN());
      return self->jointMutualInformation(sot);
    }
SWIGINTERN gum::Potential< double > gum_LazyPropagation_Sl_double_Sg__evidenceJointImpact__SWIG_0(gum::LazyPropagation< double > *self,PyObject *targets,PyObject *evs){
      gum::NodeSet sot;
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sot,targets,self->BN());
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN());
      return self->evidenceJointImpact(sot,soe);
    }
SWIGINTERN gum::Potential< double > gum_LazyPropagation_Sl_double_Sg__jointPosterior(gum::LazyPropagation< double > *self,PyObject *list){
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,list,self->BN());
      return self->jointPosterior(nodeset);
    }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__addJointTarget(gum::LazyPropagation< double > *self,PyObject *list){
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,list,self->BN());
      self->gum::JointTargetedInference<double>::addJointTarget(nodeset);
    }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__eraseJointTarget(gum::LazyPropagation< double > *self,PyObject *list){
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,list,self->BN());
      self->gum::JointTargetedInference<double>::eraseJointTarget(nodeset);
    }
SWIGINTERN bool gum_LazyPropagation_Sl_double_Sg__isJointTarget(gum::LazyPropagation< double > *self,PyObject *list){
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,list,self->BN());
      return self->gum::JointTargetedInference<double>::isJointTarget(nodeset);
    }
SWIGINTERN PyObject *gum_LazyPropagation_Sl_double_Sg__jointTargets(gum::LazyPropagation< double > const *self){
      PyObject* q = PyList_New( 0 );

      for ( auto ns : self->JointTargetedInference<double>::jointTargets()) {
        PyList_Append( q,PyAgrumHelper::PyListFromNodeSet(ns));
      }
      return q;
    }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__makeInference(gum::LazyPropagation< double > *self){
    self->gum::BayesNetInference<double>::makeInference();
  }
SWIGINTERN gum::Potential< double > const gum_LazyPropagation_Sl_double_Sg__posterior__SWIG_0(gum::LazyPropagation< double > *self,gum::NodeId const var){
    return self->MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Potential< double > const gum_LazyPropagation_Sl_double_Sg__posterior__SWIG_1(gum::LazyPropagation< double > *self,std::string const nodeName){
    return self->MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN gum::IBayesNet< double > const &gum_LazyPropagation_Sl_double_Sg__BN(gum::LazyPropagation< double > const *self){
    return self->BayesNetInference<double>::BN();
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__addEvidence__SWIG_0(gum::LazyPropagation< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__addEvidence__SWIG_1(gum::LazyPropagation< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__addEvidence__SWIG_2(gum::LazyPropagation< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__addEvidence__SWIG_3(gum::LazyPropagation< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__addEvidence__SWIG_4(gum::LazyPropagation< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::addEvidence(id,vals);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__addEvidence__SWIG_5(gum::LazyPropagation< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_0(gum::LazyPropagation< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_1(gum::LazyPropagation< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_2(gum::LazyPropagation< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_3(gum::LazyPropagation< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_4(gum::LazyPropagation< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_5(gum::LazyPropagation< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,vals);
  }
SWIGINTERN bool gum_LazyPropagation_Sl_double_Sg__hasEvidence__SWIG_0(gum::LazyPropagation< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasEvidence(id);
  }
SWIGINTERN bool gum_LazyPropagation_Sl_double_Sg__hasEvidence__SWIG_1(gum::LazyPropagation< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__eraseAllEvidence(gum::LazyPropagation< double > *self){
    self->gum::BayesNetInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__eraseEvidence__SWIG_0(gum::LazyPropagation< double > *self,gum::NodeId const id){
    self->gum::BayesNetInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__eraseEvidence__SWIG_1(gum::LazyPropagation< double > *self,std::string const &nodeName){
    self->gum::BayesNetInference<double>::eraseEvidence(nodeName);
  }
SWIGINTERN bool gum_LazyPropagation_Sl_double_Sg__hasSoftEvidence__SWIG_0(gum::LazyPropagation< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_LazyPropagation_Sl_double_Sg__hasHardEvidence(gum::LazyPropagation< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasHardEvidence(nodeName);
  }
SWIGINTERN bool gum_LazyPropagation_Sl_double_Sg__hasSoftEvidence__SWIG_1(gum::LazyPropagation< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_LazyPropagation_Sl_double_Sg__nbrEvidence(gum::LazyPropagation< double > const *self){
    return self->gum::BayesNetInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_LazyPropagation_Sl_double_Sg__nbrHardEvidence(gum::LazyPropagation< double > const *self){
    return self->gum::BayesNetInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_LazyPropagation_Sl_double_Sg__nbrSoftEvidence(gum::LazyPropagation< double > const *self){
    return self->gum::BayesNetInference<double>::nbrSoftEvidence();
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__eraseAllTargets(gum::LazyPropagation< double > *self){
      self->gum::MarginalTargetedInference<double>::eraseAllTargets();
    }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__addAllTargets(gum::LazyPropagation< double > *self){
      self->gum::MarginalTargetedInference<double>::addAllTargets();
    }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__addTarget__SWIG_0(gum::LazyPropagation< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::addTarget(target);
    }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__addTarget__SWIG_1(gum::LazyPropagation< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::addTarget(nodeName);
    }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__eraseTarget__SWIG_0(gum::LazyPropagation< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::eraseTarget(target);
    }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__eraseTarget__SWIG_1(gum::LazyPropagation< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::eraseTarget(nodeName);
    }
SWIGINTERN bool gum_LazyPropagation_Sl_double_Sg__isTarget__SWIG_0(gum::LazyPropagation< double > const *self,gum::NodeId const variable){
      return self->gum::MarginalTargetedInference<double>::isTarget(variable);
    }
SWIGINTERN bool gum_LazyPropagation_Sl_double_Sg__isTarget__SWIG_1(gum::LazyPropagation< double > const *self,std::string const &nodeName){
      return self->gum::MarginalTargetedInference<double>::isTarget(nodeName);
    }
SWIGINTERN gum::Size gum_LazyPropagation_Sl_double_Sg__nbrTargets(gum::LazyPropagation< double > const *self){
      return self->gum::MarginalTargetedInference<double>::nbrTargets();
    }
SWIGINTERN double gum_LazyPropagation_Sl_double_Sg__H__SWIG_0(gum::LazyPropagation< double > *self,gum::NodeId const X){
     return self->gum::MarginalTargetedInference<double>::H(X);
   }
SWIGINTERN double gum_LazyPropagation_Sl_double_Sg__H__SWIG_1(gum::LazyPropagation< double > *self,std::string const &nodeName){
     return self->gum::MarginalTargetedInference<double>::H(nodeName);
   }
SWIGINTERN gum::Potential< double > gum_LazyPropagation_Sl_double_Sg__evidenceImpact__SWIG_1(gum::LazyPropagation< double > *self,std::string const &target,std::vector< std::string,std::allocator< std::string > > const &evs){
   return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__eraseAllJointTargets(gum::LazyPropagation< double > *self){
    self->gum::JointTargetedInference<double>::eraseAllJointTargets();
  }
SWIGINTERN void gum_LazyPropagation_Sl_double_Sg__eraseAllMarginalTargets(gum::LazyPropagation< double > *self){
    self->gum::JointTargetedInference<double>::eraseAllMarginalTargets();
  }
SWIGINTERN gum::Size gum_LazyPropagation_Sl_double_Sg__nbrJointTargets(gum::LazyPropagation< double > *self){
    return self->gum::JointTargetedInference<double>::nbrJointTargets();
  }
SWIGINTERN double gum_LazyPropagation_Sl_double_Sg__I(gum::LazyPropagation< double > *self,gum::NodeId const X,gum::NodeId const Y){
    return self->gum::JointTargetedInference<double>::I(X,Y);
  }
SWIGINTERN double gum_LazyPropagation_Sl_double_Sg__VI(gum::LazyPropagation< double > *self,gum::NodeId const X,gum::NodeId const Y){
    return self->gum::JointTargetedInference<double>::VI(X,Y);
  }
SWIGINTERN gum::Potential< double > gum_LazyPropagation_Sl_double_Sg__evidenceJointImpact__SWIG_1(gum::LazyPropagation< double > *self,std::vector< std::string,std::allocator< std::string > > const &targets,std::vector< std::string,std::allocator< std::string > > const &evs){
   return self->gum::JointTargetedInference<double>::evidenceJointImpact(targets,evs);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__setEvidence(gum::ShaferShenoyInference< double > *self,PyObject *evidces){}
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__updateEvidence(gum::ShaferShenoyInference< double > *self,PyObject *evidces){}
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__setTargets(gum::ShaferShenoyInference< double > *self,PyObject *targets){}
SWIGINTERN PyObject *gum_ShaferShenoyInference_Sl_double_Sg__hardEvidenceNodes(gum::ShaferShenoyInference< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_ShaferShenoyInference_Sl_double_Sg__softEvidenceNodes(gum::ShaferShenoyInference< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_ShaferShenoyInference_Sl_double_Sg__targets(gum::ShaferShenoyInference< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->targets() );
    }
SWIGINTERN gum::Potential< double > gum_ShaferShenoyInference_Sl_double_Sg__evidenceImpact__SWIG_0(gum::ShaferShenoyInference< double > *self,gum::NodeId target,PyObject *evs){
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN());
      return self->evidenceImpact(target,soe);
    }
SWIGINTERN double gum_ShaferShenoyInference_Sl_double_Sg__jointMutualInformation(gum::ShaferShenoyInference< double > *self,PyObject *targets){
      gum::NodeSet sot;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sot,targets,self->BN());
      return self->jointMutualInformation(sot);
    }
SWIGINTERN gum::Potential< double > gum_ShaferShenoyInference_Sl_double_Sg__evidenceJointImpact__SWIG_0(gum::ShaferShenoyInference< double > *self,PyObject *targets,PyObject *evs){
      gum::NodeSet sot;
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sot,targets,self->BN());
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN());
      return self->evidenceJointImpact(sot,soe);
    }
SWIGINTERN gum::Potential< double > gum_ShaferShenoyInference_Sl_double_Sg__jointPosterior(gum::ShaferShenoyInference< double > *self,PyObject *list){
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,list,self->BN());
      return self->jointPosterior(nodeset);
    }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__addJointTarget(gum::ShaferShenoyInference< double > *self,PyObject *list){
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,list,self->BN());
      self->gum::JointTargetedInference<double>::addJointTarget(nodeset);
    }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__eraseJointTarget(gum::ShaferShenoyInference< double > *self,PyObject *list){
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,list,self->BN());
      self->gum::JointTargetedInference<double>::eraseJointTarget(nodeset);
    }
SWIGINTERN bool gum_ShaferShenoyInference_Sl_double_Sg__isJointTarget(gum::ShaferShenoyInference< double > *self,PyObject *list){
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,list,self->BN());
      return self->gum::JointTargetedInference<double>::isJointTarget(nodeset);
    }
SWIGINTERN PyObject *gum_ShaferShenoyInference_Sl_double_Sg__jointTargets(gum::ShaferShenoyInference< double > const *self){
      PyObject* q = PyList_New( 0 );

      for ( auto ns : self->JointTargetedInference<double>::jointTargets()) {
        PyList_Append( q,PyAgrumHelper::PyListFromNodeSet(ns));
      }
      return q;
    }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__makeInference(gum::ShaferShenoyInference< double > *self){
    self->gum::BayesNetInference<double>::makeInference();
  }
SWIGINTERN gum::Potential< double > const gum_ShaferShenoyInference_Sl_double_Sg__posterior__SWIG_0(gum::ShaferShenoyInference< double > *self,gum::NodeId const var){
    return self->MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Potential< double > const gum_ShaferShenoyInference_Sl_double_Sg__posterior__SWIG_1(gum::ShaferShenoyInference< double > *self,std::string const nodeName){
    return self->MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN gum::IBayesNet< double > const &gum_ShaferShenoyInference_Sl_double_Sg__BN(gum::ShaferShenoyInference< double > const *self){
    return self->BayesNetInference<double>::BN();
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__addEvidence__SWIG_0(gum::ShaferShenoyInference< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__addEvidence__SWIG_1(gum::ShaferShenoyInference< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__addEvidence__SWIG_2(gum::ShaferShenoyInference< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__addEvidence__SWIG_3(gum::ShaferShenoyInference< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__addEvidence__SWIG_4(gum::ShaferShenoyInference< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::addEvidence(id,vals);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__addEvidence__SWIG_5(gum::ShaferShenoyInference< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_0(gum::ShaferShenoyInference< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_1(gum::ShaferShenoyInference< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_2(gum::ShaferShenoyInference< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_3(gum::ShaferShenoyInference< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_4(gum::ShaferShenoyInference< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_5(gum::ShaferShenoyInference< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,vals);
  }
SWIGINTERN bool gum_ShaferShenoyInference_Sl_double_Sg__hasEvidence__SWIG_0(gum::ShaferShenoyInference< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasEvidence(id);
  }
SWIGINTERN bool gum_ShaferShenoyInference_Sl_double_Sg__hasEvidence__SWIG_1(gum::ShaferShenoyInference< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__eraseAllEvidence(gum::ShaferShenoyInference< double > *self){
    self->gum::BayesNetInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__eraseEvidence__SWIG_0(gum::ShaferShenoyInference< double > *self,gum::NodeId const id){
    self->gum::BayesNetInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__eraseEvidence__SWIG_1(gum::ShaferShenoyInference< double > *self,std::string const &nodeName){
    self->gum::BayesNetInference<double>::eraseEvidence(nodeName);
  }
SWIGINTERN bool gum_ShaferShenoyInference_Sl_double_Sg__hasSoftEvidence__SWIG_0(gum::ShaferShenoyInference< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_ShaferShenoyInference_Sl_double_Sg__hasHardEvidence(gum::ShaferShenoyInference< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasHardEvidence(nodeName);
  }
SWIGINTERN bool gum_ShaferShenoyInference_Sl_double_Sg__hasSoftEvidence__SWIG_1(gum::ShaferShenoyInference< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_ShaferShenoyInference_Sl_double_Sg__nbrEvidence(gum::ShaferShenoyInference< double > const *self){
    return self->gum::BayesNetInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_ShaferShenoyInference_Sl_double_Sg__nbrHardEvidence(gum::ShaferShenoyInference< double > const *self){
    return self->gum::BayesNetInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_ShaferShenoyInference_Sl_double_Sg__nbrSoftEvidence(gum::ShaferShenoyInference< double > const *self){
    return self->gum::BayesNetInference<double>::nbrSoftEvidence();
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__eraseAllTargets(gum::ShaferShenoyInference< double > *self){
      self->gum::MarginalTargetedInference<double>::eraseAllTargets();
    }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__addAllTargets(gum::ShaferShenoyInference< double > *self){
      self->gum::MarginalTargetedInference<double>::addAllTargets();
    }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__addTarget__SWIG_0(gum::ShaferShenoyInference< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::addTarget(target);
    }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__addTarget__SWIG_1(gum::ShaferShenoyInference< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::addTarget(nodeName);
    }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__eraseTarget__SWIG_0(gum::ShaferShenoyInference< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::eraseTarget(target);
    }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__eraseTarget__SWIG_1(gum::ShaferShenoyInference< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::eraseTarget(nodeName);
    }
SWIGINTERN bool gum_ShaferShenoyInference_Sl_double_Sg__isTarget__SWIG_0(gum::ShaferShenoyInference< double > const *self,gum::NodeId const variable){
      return self->gum::MarginalTargetedInference<double>::isTarget(variable);
    }
SWIGINTERN bool gum_ShaferShenoyInference_Sl_double_Sg__isTarget__SWIG_1(gum::ShaferShenoyInference< double > const *self,std::string const &nodeName){
      return self->gum::MarginalTargetedInference<double>::isTarget(nodeName);
    }
SWIGINTERN gum::Size gum_ShaferShenoyInference_Sl_double_Sg__nbrTargets(gum::ShaferShenoyInference< double > const *self){
      return self->gum::MarginalTargetedInference<double>::nbrTargets();
    }
SWIGINTERN double gum_ShaferShenoyInference_Sl_double_Sg__H__SWIG_0(gum::ShaferShenoyInference< double > *self,gum::NodeId const X){
     return self->gum::MarginalTargetedInference<double>::H(X);
   }
SWIGINTERN double gum_ShaferShenoyInference_Sl_double_Sg__H__SWIG_1(gum::ShaferShenoyInference< double > *self,std::string const &nodeName){
     return self->gum::MarginalTargetedInference<double>::H(nodeName);
   }
SWIGINTERN gum::Potential< double > gum_ShaferShenoyInference_Sl_double_Sg__evidenceImpact__SWIG_1(gum::ShaferShenoyInference< double > *self,std::string const &target,std::vector< std::string,std::allocator< std::string > > const &evs){
   return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__eraseAllJointTargets(gum::ShaferShenoyInference< double > *self){
    self->gum::JointTargetedInference<double>::eraseAllJointTargets();
  }
SWIGINTERN void gum_ShaferShenoyInference_Sl_double_Sg__eraseAllMarginalTargets(gum::ShaferShenoyInference< double > *self){
    self->gum::JointTargetedInference<double>::eraseAllMarginalTargets();
  }
SWIGINTERN gum::Size gum_ShaferShenoyInference_Sl_double_Sg__nbrJointTargets(gum::ShaferShenoyInference< double > *self){
    return self->gum::JointTargetedInference<double>::nbrJointTargets();
  }
SWIGINTERN double gum_ShaferShenoyInference_Sl_double_Sg__I(gum::ShaferShenoyInference< double > *self,gum::NodeId const X,gum::NodeId const Y){
    return self->gum::JointTargetedInference<double>::I(X,Y);
  }
SWIGINTERN double gum_ShaferShenoyInference_Sl_double_Sg__VI(gum::ShaferShenoyInference< double > *self,gum::NodeId const X,gum::NodeId const Y){
    return self->gum::JointTargetedInference<double>::VI(X,Y);
  }
SWIGINTERN gum::Potential< double > gum_ShaferShenoyInference_Sl_double_Sg__evidenceJointImpact__SWIG_1(gum::ShaferShenoyInference< double > *self,std::vector< std::string,std::allocator< std::string > > const &targets,std::vector< std::string,std::allocator< std::string > > const &evs){
   return self->gum::JointTargetedInference<double>::evidenceJointImpact(targets,evs);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__setEvidence(gum::VariableElimination< double > *self,PyObject *evidces){}
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__updateEvidence(gum::VariableElimination< double > *self,PyObject *evidces){}
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__setTargets(gum::VariableElimination< double > *self,PyObject *targets){}
SWIGINTERN PyObject *gum_VariableElimination_Sl_double_Sg__hardEvidenceNodes(gum::VariableElimination< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_VariableElimination_Sl_double_Sg__softEvidenceNodes(gum::VariableElimination< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_VariableElimination_Sl_double_Sg__targets(gum::VariableElimination< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->targets() );
    }
SWIGINTERN gum::Potential< double > gum_VariableElimination_Sl_double_Sg__evidenceImpact__SWIG_0(gum::VariableElimination< double > *self,gum::NodeId target,PyObject *evs){
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN());
      return self->evidenceImpact(target,soe);
    }
SWIGINTERN double gum_VariableElimination_Sl_double_Sg__jointMutualInformation(gum::VariableElimination< double > *self,PyObject *targets){
      gum::NodeSet sot;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sot,targets,self->BN());
      return self->jointMutualInformation(sot);
    }
SWIGINTERN gum::Potential< double > gum_VariableElimination_Sl_double_Sg__evidenceJointImpact(gum::VariableElimination< double > *self,PyObject *targets,PyObject *evs){
      gum::NodeSet sot;
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(sot,targets,self->BN());
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN());
      return self->evidenceJointImpact(sot,soe);
    }
SWIGINTERN gum::Potential< double > gum_VariableElimination_Sl_double_Sg__jointPosterior(gum::VariableElimination< double > *self,PyObject *list){
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,list,self->BN());
      return self->jointPosterior(nodeset);
    }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__addJointTarget(gum::VariableElimination< double > *self,PyObject *list){
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,list,self->BN());
      self->gum::JointTargetedInference<double>::addJointTarget(nodeset);
    }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__eraseJointTarget(gum::VariableElimination< double > *self,PyObject *list){
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,list,self->BN());
      self->gum::JointTargetedInference<double>::eraseJointTarget(nodeset);
    }
SWIGINTERN bool gum_VariableElimination_Sl_double_Sg__isJointTarget(gum::VariableElimination< double > *self,PyObject *list){
      gum::NodeSet nodeset;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(nodeset,list,self->BN());
      return self->gum::JointTargetedInference<double>::isJointTarget(nodeset);
    }
SWIGINTERN PyObject *gum_VariableElimination_Sl_double_Sg__jointTargets(gum::VariableElimination< double > const *self){
      PyObject* q = PyList_New( 0 );

      for ( auto ns : self->JointTargetedInference<double>::jointTargets()) {
        PyList_Append( q,PyAgrumHelper::PyListFromNodeSet(ns));
      }
      return q;
    }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__makeInference(gum::VariableElimination< double > *self){
    self->gum::BayesNetInference<double>::makeInference();
  }
SWIGINTERN gum::Potential< double > const gum_VariableElimination_Sl_double_Sg__posterior__SWIG_0(gum::VariableElimination< double > *self,gum::NodeId const var){
    return self->MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Potential< double > const gum_VariableElimination_Sl_double_Sg__posterior__SWIG_1(gum::VariableElimination< double > *self,std::string const nodeName){
    return self->MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN gum::IBayesNet< double > const &gum_VariableElimination_Sl_double_Sg__BN(gum::VariableElimination< double > const *self){
    return self->BayesNetInference<double>::BN();
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__addEvidence__SWIG_0(gum::VariableElimination< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__addEvidence__SWIG_1(gum::VariableElimination< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__addEvidence__SWIG_2(gum::VariableElimination< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__addEvidence__SWIG_3(gum::VariableElimination< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__addEvidence__SWIG_4(gum::VariableElimination< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::addEvidence(id,vals);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__addEvidence__SWIG_5(gum::VariableElimination< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_0(gum::VariableElimination< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_1(gum::VariableElimination< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_2(gum::VariableElimination< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_3(gum::VariableElimination< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_4(gum::VariableElimination< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_5(gum::VariableElimination< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,vals);
  }
SWIGINTERN bool gum_VariableElimination_Sl_double_Sg__hasEvidence__SWIG_0(gum::VariableElimination< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasEvidence(id);
  }
SWIGINTERN bool gum_VariableElimination_Sl_double_Sg__hasEvidence__SWIG_1(gum::VariableElimination< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__eraseAllEvidence(gum::VariableElimination< double > *self){
    self->gum::BayesNetInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__eraseEvidence__SWIG_0(gum::VariableElimination< double > *self,gum::NodeId const id){
    self->gum::BayesNetInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__eraseEvidence__SWIG_1(gum::VariableElimination< double > *self,std::string const &nodeName){
    self->gum::BayesNetInference<double>::eraseEvidence(nodeName);
  }
SWIGINTERN bool gum_VariableElimination_Sl_double_Sg__hasSoftEvidence__SWIG_0(gum::VariableElimination< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_VariableElimination_Sl_double_Sg__hasHardEvidence(gum::VariableElimination< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasHardEvidence(nodeName);
  }
SWIGINTERN bool gum_VariableElimination_Sl_double_Sg__hasSoftEvidence__SWIG_1(gum::VariableElimination< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_VariableElimination_Sl_double_Sg__nbrEvidence(gum::VariableElimination< double > const *self){
    return self->gum::BayesNetInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_VariableElimination_Sl_double_Sg__nbrHardEvidence(gum::VariableElimination< double > const *self){
    return self->gum::BayesNetInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_VariableElimination_Sl_double_Sg__nbrSoftEvidence(gum::VariableElimination< double > const *self){
    return self->gum::BayesNetInference<double>::nbrSoftEvidence();
  }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__eraseAllTargets(gum::VariableElimination< double > *self){
      self->gum::MarginalTargetedInference<double>::eraseAllTargets();
    }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__addAllTargets(gum::VariableElimination< double > *self){
      self->gum::MarginalTargetedInference<double>::addAllTargets();
    }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__addTarget__SWIG_0(gum::VariableElimination< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::addTarget(target);
    }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__addTarget__SWIG_1(gum::VariableElimination< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::addTarget(nodeName);
    }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__eraseTarget__SWIG_0(gum::VariableElimination< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::eraseTarget(target);
    }
SWIGINTERN void gum_VariableElimination_Sl_double_Sg__eraseTarget__SWIG_1(gum::VariableElimination< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::eraseTarget(nodeName);
    }
SWIGINTERN bool gum_VariableElimination_Sl_double_Sg__isTarget__SWIG_0(gum::VariableElimination< double > const *self,gum::NodeId const variable){
      return self->gum::MarginalTargetedInference<double>::isTarget(variable);
    }
SWIGINTERN bool gum_VariableElimination_Sl_double_Sg__isTarget__SWIG_1(gum::VariableElimination< double > const *self,std::string const &nodeName){
      return self->gum::MarginalTargetedInference<double>::isTarget(nodeName);
    }
SWIGINTERN gum::Size gum_VariableElimination_Sl_double_Sg__nbrTargets(gum::VariableElimination< double > const *self){
      return self->gum::MarginalTargetedInference<double>::nbrTargets();
    }
SWIGINTERN double gum_VariableElimination_Sl_double_Sg__H__SWIG_0(gum::VariableElimination< double > *self,gum::NodeId const X){
     return self->gum::MarginalTargetedInference<double>::H(X);
   }
SWIGINTERN double gum_VariableElimination_Sl_double_Sg__H__SWIG_1(gum::VariableElimination< double > *self,std::string const &nodeName){
     return self->gum::MarginalTargetedInference<double>::H(nodeName);
   }
SWIGINTERN gum::Potential< double > gum_VariableElimination_Sl_double_Sg__evidenceImpact__SWIG_1(gum::VariableElimination< double > *self,std::string const &target,std::vector< std::string,std::allocator< std::string > > const &evs){
   return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__setEvidence(gum::GibbsSampling< double > *self,PyObject *evidces){}
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__updateEvidence(gum::GibbsSampling< double > *self,PyObject *evidces){}
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__setTargets(gum::GibbsSampling< double > *self,PyObject *targets){}
SWIGINTERN PyObject *gum_GibbsSampling_Sl_double_Sg__hardEvidenceNodes(gum::GibbsSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_GibbsSampling_Sl_double_Sg__softEvidenceNodes(gum::GibbsSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_GibbsSampling_Sl_double_Sg__targets(gum::GibbsSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->targets() );
    }
SWIGINTERN gum::Potential< double > gum_GibbsSampling_Sl_double_Sg__evidenceImpact__SWIG_0(gum::GibbsSampling< double > *self,gum::NodeId target,PyObject *evs){
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN());
      return self->evidenceImpact(target,soe);
    }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__setVerbosity(gum::GibbsSampling< double > *self,bool v){ self->gum::ApproximationScheme::setVerbosity(v); }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__setEpsilon(gum::GibbsSampling< double > *self,double eps){ self->gum::ApproximationScheme::setEpsilon(eps); }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__setMinEpsilonRate(gum::GibbsSampling< double > *self,double rate){ self->gum::ApproximationScheme::setMinEpsilonRate(rate); }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__setMaxIter(gum::GibbsSampling< double > *self,gum::Size max){ self->gum::ApproximationScheme::setMaxIter(max); }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__setMaxTime(gum::GibbsSampling< double > *self,double timeout){ self->gum::ApproximationScheme::setMaxTime(timeout); }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__setPeriodSize(gum::GibbsSampling< double > *self,gum::Size p){ self->gum::ApproximationScheme::setPeriodSize(p); }
SWIGINTERN bool gum_GibbsSampling_Sl_double_Sg__verbosity(gum::GibbsSampling< double > const *self){ return self->gum::ApproximationScheme::verbosity(); }
SWIGINTERN double gum_GibbsSampling_Sl_double_Sg__epsilon(gum::GibbsSampling< double > const *self){ return self->gum::ApproximationScheme::epsilon(); }
SWIGINTERN double gum_GibbsSampling_Sl_double_Sg__minEpsilonRate(gum::GibbsSampling< double > const *self){ return self->gum::ApproximationScheme::minEpsilonRate(); }
SWIGINTERN gum::Size gum_GibbsSampling_Sl_double_Sg__maxIter(gum::GibbsSampling< double > const *self){ return self->gum::ApproximationScheme::maxIter(); }
SWIGINTERN double gum_GibbsSampling_Sl_double_Sg__maxTime(gum::GibbsSampling< double > const *self){ return self->gum::ApproximationScheme::maxTime(); }
SWIGINTERN gum::Size gum_GibbsSampling_Sl_double_Sg__periodSize(gum::GibbsSampling< double > const *self){ return self->gum::ApproximationScheme::periodSize(); }
SWIGINTERN gum::Size gum_GibbsSampling_Sl_double_Sg__nbrIterations(gum::GibbsSampling< double > const *self){ return self->gum::ApproximationScheme::nbrIterations(); }
SWIGINTERN double gum_GibbsSampling_Sl_double_Sg__currentTime(gum::GibbsSampling< double > const *self){ return self->gum::ApproximationScheme::currentTime(); }
SWIGINTERN std::string gum_GibbsSampling_Sl_double_Sg__messageApproximationScheme(gum::GibbsSampling< double > const *self){ return self->gum::ApproximationScheme::messageApproximationScheme(); }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_GibbsSampling_Sl_double_Sg__history(gum::GibbsSampling< double > const *self){ return self->gum::ApproximationScheme::history(); }
SWIGINTERN gum::IApproximationSchemeConfiguration const &gum_GibbsSampling_Sl_double_Sg__asIApproximationSchemeConfiguration(gum::GibbsSampling< double > const *self){
    return *(dynamic_cast<const gum::IApproximationSchemeConfiguration *>(self));
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__makeInference(gum::GibbsSampling< double > *self){
    self->gum::BayesNetInference<double>::makeInference();
  }
SWIGINTERN gum::Potential< double > const gum_GibbsSampling_Sl_double_Sg__posterior__SWIG_0(gum::GibbsSampling< double > *self,gum::NodeId const var){
    return self->MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Potential< double > const gum_GibbsSampling_Sl_double_Sg__posterior__SWIG_1(gum::GibbsSampling< double > *self,std::string const nodeName){
    return self->MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN gum::IBayesNet< double > const &gum_GibbsSampling_Sl_double_Sg__BN(gum::GibbsSampling< double > const *self){
    return self->BayesNetInference<double>::BN();
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__addEvidence__SWIG_0(gum::GibbsSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__addEvidence__SWIG_1(gum::GibbsSampling< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__addEvidence__SWIG_2(gum::GibbsSampling< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__addEvidence__SWIG_3(gum::GibbsSampling< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__addEvidence__SWIG_4(gum::GibbsSampling< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::addEvidence(id,vals);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__addEvidence__SWIG_5(gum::GibbsSampling< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_0(gum::GibbsSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_1(gum::GibbsSampling< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_2(gum::GibbsSampling< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_3(gum::GibbsSampling< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_4(gum::GibbsSampling< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_5(gum::GibbsSampling< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,vals);
  }
SWIGINTERN bool gum_GibbsSampling_Sl_double_Sg__hasEvidence__SWIG_0(gum::GibbsSampling< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasEvidence(id);
  }
SWIGINTERN bool gum_GibbsSampling_Sl_double_Sg__hasEvidence__SWIG_1(gum::GibbsSampling< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__eraseAllEvidence(gum::GibbsSampling< double > *self){
    self->gum::BayesNetInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__eraseEvidence__SWIG_0(gum::GibbsSampling< double > *self,gum::NodeId const id){
    self->gum::BayesNetInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__eraseEvidence__SWIG_1(gum::GibbsSampling< double > *self,std::string const &nodeName){
    self->gum::BayesNetInference<double>::eraseEvidence(nodeName);
  }
SWIGINTERN bool gum_GibbsSampling_Sl_double_Sg__hasSoftEvidence__SWIG_0(gum::GibbsSampling< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_GibbsSampling_Sl_double_Sg__hasHardEvidence(gum::GibbsSampling< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasHardEvidence(nodeName);
  }
SWIGINTERN bool gum_GibbsSampling_Sl_double_Sg__hasSoftEvidence__SWIG_1(gum::GibbsSampling< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_GibbsSampling_Sl_double_Sg__nbrEvidence(gum::GibbsSampling< double > const *self){
    return self->gum::BayesNetInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_GibbsSampling_Sl_double_Sg__nbrHardEvidence(gum::GibbsSampling< double > const *self){
    return self->gum::BayesNetInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_GibbsSampling_Sl_double_Sg__nbrSoftEvidence(gum::GibbsSampling< double > const *self){
    return self->gum::BayesNetInference<double>::nbrSoftEvidence();
  }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__eraseAllTargets(gum::GibbsSampling< double > *self){
      self->gum::MarginalTargetedInference<double>::eraseAllTargets();
    }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__addAllTargets(gum::GibbsSampling< double > *self){
      self->gum::MarginalTargetedInference<double>::addAllTargets();
    }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__addTarget__SWIG_0(gum::GibbsSampling< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::addTarget(target);
    }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__addTarget__SWIG_1(gum::GibbsSampling< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::addTarget(nodeName);
    }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__eraseTarget__SWIG_0(gum::GibbsSampling< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::eraseTarget(target);
    }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__eraseTarget__SWIG_1(gum::GibbsSampling< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::eraseTarget(nodeName);
    }
SWIGINTERN bool gum_GibbsSampling_Sl_double_Sg__isTarget__SWIG_0(gum::GibbsSampling< double > const *self,gum::NodeId const variable){
      return self->gum::MarginalTargetedInference<double>::isTarget(variable);
    }
SWIGINTERN bool gum_GibbsSampling_Sl_double_Sg__isTarget__SWIG_1(gum::GibbsSampling< double > const *self,std::string const &nodeName){
      return self->gum::MarginalTargetedInference<double>::isTarget(nodeName);
    }
SWIGINTERN gum::Size gum_GibbsSampling_Sl_double_Sg__nbrTargets(gum::GibbsSampling< double > const *self){
      return self->gum::MarginalTargetedInference<double>::nbrTargets();
    }
SWIGINTERN double gum_GibbsSampling_Sl_double_Sg__H__SWIG_0(gum::GibbsSampling< double > *self,gum::NodeId const X){
     return self->gum::MarginalTargetedInference<double>::H(X);
   }
SWIGINTERN double gum_GibbsSampling_Sl_double_Sg__H__SWIG_1(gum::GibbsSampling< double > *self,std::string const &nodeName){
     return self->gum::MarginalTargetedInference<double>::H(nodeName);
   }
SWIGINTERN gum::Potential< double > gum_GibbsSampling_Sl_double_Sg__evidenceImpact__SWIG_1(gum::GibbsSampling< double > *self,std::string const &target,std::vector< std::string,std::allocator< std::string > > const &evs){
   return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Potential< double > const &gum_GibbsSampling_Sl_double_Sg__currentPosterior__SWIG_0(gum::GibbsSampling< double > *self,gum::NodeId const id){return self->gum::SamplingInference<double>::currentPosterior(id);}
SWIGINTERN gum::Potential< double > const &gum_GibbsSampling_Sl_double_Sg__currentPosterior__SWIG_1(gum::GibbsSampling< double > *self,std::string const &name){return self->gum::SamplingInference<double>::currentPosterior(name);}
SWIGINTERN gum::Size gum_GibbsSampling_Sl_double_Sg__nbrDrawnVar(gum::GibbsSampling< double > const *self){ return self->GibbsOperator<double>::nbrDrawnVar(); }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__setNbrDrawnVar(gum::GibbsSampling< double > *self,gum::Size _nbr){ self->GibbsOperator<double>::setNbrDrawnVar(_nbr); }
SWIGINTERN bool gum_GibbsSampling_Sl_double_Sg__isDrawnAtRandom(gum::GibbsSampling< double > const *self){ return self->GibbsOperator<double>::isDrawnAtRandom(); }
SWIGINTERN void gum_GibbsSampling_Sl_double_Sg__setDrawnAtRandom(gum::GibbsSampling< double > *self,bool _atRandom){ self->GibbsOperator<double>::setDrawnAtRandom(_atRandom); }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__setEvidence(gum::ImportanceSampling< double > *self,PyObject *evidces){}
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__updateEvidence(gum::ImportanceSampling< double > *self,PyObject *evidces){}
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__setTargets(gum::ImportanceSampling< double > *self,PyObject *targets){}
SWIGINTERN PyObject *gum_ImportanceSampling_Sl_double_Sg__hardEvidenceNodes(gum::ImportanceSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_ImportanceSampling_Sl_double_Sg__softEvidenceNodes(gum::ImportanceSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_ImportanceSampling_Sl_double_Sg__targets(gum::ImportanceSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->targets() );
    }
SWIGINTERN gum::Potential< double > gum_ImportanceSampling_Sl_double_Sg__evidenceImpact__SWIG_0(gum::ImportanceSampling< double > *self,gum::NodeId target,PyObject *evs){
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN());
      return self->evidenceImpact(target,soe);
    }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__setVerbosity(gum::ImportanceSampling< double > *self,bool v){ self->gum::ApproximationScheme::setVerbosity(v); }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__setEpsilon(gum::ImportanceSampling< double > *self,double eps){ self->gum::ApproximationScheme::setEpsilon(eps); }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__setMinEpsilonRate(gum::ImportanceSampling< double > *self,double rate){ self->gum::ApproximationScheme::setMinEpsilonRate(rate); }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__setMaxIter(gum::ImportanceSampling< double > *self,gum::Size max){ self->gum::ApproximationScheme::setMaxIter(max); }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__setMaxTime(gum::ImportanceSampling< double > *self,double timeout){ self->gum::ApproximationScheme::setMaxTime(timeout); }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__setPeriodSize(gum::ImportanceSampling< double > *self,gum::Size p){ self->gum::ApproximationScheme::setPeriodSize(p); }
SWIGINTERN bool gum_ImportanceSampling_Sl_double_Sg__verbosity(gum::ImportanceSampling< double > const *self){ return self->gum::ApproximationScheme::verbosity(); }
SWIGINTERN double gum_ImportanceSampling_Sl_double_Sg__epsilon(gum::ImportanceSampling< double > const *self){ return self->gum::ApproximationScheme::epsilon(); }
SWIGINTERN double gum_ImportanceSampling_Sl_double_Sg__minEpsilonRate(gum::ImportanceSampling< double > const *self){ return self->gum::ApproximationScheme::minEpsilonRate(); }
SWIGINTERN gum::Size gum_ImportanceSampling_Sl_double_Sg__maxIter(gum::ImportanceSampling< double > const *self){ return self->gum::ApproximationScheme::maxIter(); }
SWIGINTERN double gum_ImportanceSampling_Sl_double_Sg__maxTime(gum::ImportanceSampling< double > const *self){ return self->gum::ApproximationScheme::maxTime(); }
SWIGINTERN gum::Size gum_ImportanceSampling_Sl_double_Sg__periodSize(gum::ImportanceSampling< double > const *self){ return self->gum::ApproximationScheme::periodSize(); }
SWIGINTERN gum::Size gum_ImportanceSampling_Sl_double_Sg__nbrIterations(gum::ImportanceSampling< double > const *self){ return self->gum::ApproximationScheme::nbrIterations(); }
SWIGINTERN double gum_ImportanceSampling_Sl_double_Sg__currentTime(gum::ImportanceSampling< double > const *self){ return self->gum::ApproximationScheme::currentTime(); }
SWIGINTERN std::string gum_ImportanceSampling_Sl_double_Sg__messageApproximationScheme(gum::ImportanceSampling< double > const *self){ return self->gum::ApproximationScheme::messageApproximationScheme(); }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_ImportanceSampling_Sl_double_Sg__history(gum::ImportanceSampling< double > const *self){ return self->gum::ApproximationScheme::history(); }
SWIGINTERN gum::IApproximationSchemeConfiguration const &gum_ImportanceSampling_Sl_double_Sg__asIApproximationSchemeConfiguration(gum::ImportanceSampling< double > const *self){
    return *(dynamic_cast<const gum::IApproximationSchemeConfiguration *>(self));
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__makeInference(gum::ImportanceSampling< double > *self){
    self->gum::BayesNetInference<double>::makeInference();
  }
SWIGINTERN gum::Potential< double > const gum_ImportanceSampling_Sl_double_Sg__posterior__SWIG_0(gum::ImportanceSampling< double > *self,gum::NodeId const var){
    return self->MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Potential< double > const gum_ImportanceSampling_Sl_double_Sg__posterior__SWIG_1(gum::ImportanceSampling< double > *self,std::string const nodeName){
    return self->MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN gum::IBayesNet< double > const &gum_ImportanceSampling_Sl_double_Sg__BN(gum::ImportanceSampling< double > const *self){
    return self->BayesNetInference<double>::BN();
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__addEvidence__SWIG_0(gum::ImportanceSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__addEvidence__SWIG_1(gum::ImportanceSampling< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__addEvidence__SWIG_2(gum::ImportanceSampling< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__addEvidence__SWIG_3(gum::ImportanceSampling< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__addEvidence__SWIG_4(gum::ImportanceSampling< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::addEvidence(id,vals);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__addEvidence__SWIG_5(gum::ImportanceSampling< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_0(gum::ImportanceSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_1(gum::ImportanceSampling< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_2(gum::ImportanceSampling< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_3(gum::ImportanceSampling< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_4(gum::ImportanceSampling< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_5(gum::ImportanceSampling< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,vals);
  }
SWIGINTERN bool gum_ImportanceSampling_Sl_double_Sg__hasEvidence__SWIG_0(gum::ImportanceSampling< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasEvidence(id);
  }
SWIGINTERN bool gum_ImportanceSampling_Sl_double_Sg__hasEvidence__SWIG_1(gum::ImportanceSampling< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__eraseAllEvidence(gum::ImportanceSampling< double > *self){
    self->gum::BayesNetInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__eraseEvidence__SWIG_0(gum::ImportanceSampling< double > *self,gum::NodeId const id){
    self->gum::BayesNetInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__eraseEvidence__SWIG_1(gum::ImportanceSampling< double > *self,std::string const &nodeName){
    self->gum::BayesNetInference<double>::eraseEvidence(nodeName);
  }
SWIGINTERN bool gum_ImportanceSampling_Sl_double_Sg__hasSoftEvidence__SWIG_0(gum::ImportanceSampling< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_ImportanceSampling_Sl_double_Sg__hasHardEvidence(gum::ImportanceSampling< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasHardEvidence(nodeName);
  }
SWIGINTERN bool gum_ImportanceSampling_Sl_double_Sg__hasSoftEvidence__SWIG_1(gum::ImportanceSampling< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_ImportanceSampling_Sl_double_Sg__nbrEvidence(gum::ImportanceSampling< double > const *self){
    return self->gum::BayesNetInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_ImportanceSampling_Sl_double_Sg__nbrHardEvidence(gum::ImportanceSampling< double > const *self){
    return self->gum::BayesNetInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_ImportanceSampling_Sl_double_Sg__nbrSoftEvidence(gum::ImportanceSampling< double > const *self){
    return self->gum::BayesNetInference<double>::nbrSoftEvidence();
  }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__eraseAllTargets(gum::ImportanceSampling< double > *self){
      self->gum::MarginalTargetedInference<double>::eraseAllTargets();
    }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__addAllTargets(gum::ImportanceSampling< double > *self){
      self->gum::MarginalTargetedInference<double>::addAllTargets();
    }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__addTarget__SWIG_0(gum::ImportanceSampling< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::addTarget(target);
    }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__addTarget__SWIG_1(gum::ImportanceSampling< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::addTarget(nodeName);
    }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__eraseTarget__SWIG_0(gum::ImportanceSampling< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::eraseTarget(target);
    }
SWIGINTERN void gum_ImportanceSampling_Sl_double_Sg__eraseTarget__SWIG_1(gum::ImportanceSampling< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::eraseTarget(nodeName);
    }
SWIGINTERN bool gum_ImportanceSampling_Sl_double_Sg__isTarget__SWIG_0(gum::ImportanceSampling< double > const *self,gum::NodeId const variable){
      return self->gum::MarginalTargetedInference<double>::isTarget(variable);
    }
SWIGINTERN bool gum_ImportanceSampling_Sl_double_Sg__isTarget__SWIG_1(gum::ImportanceSampling< double > const *self,std::string const &nodeName){
      return self->gum::MarginalTargetedInference<double>::isTarget(nodeName);
    }
SWIGINTERN gum::Size gum_ImportanceSampling_Sl_double_Sg__nbrTargets(gum::ImportanceSampling< double > const *self){
      return self->gum::MarginalTargetedInference<double>::nbrTargets();
    }
SWIGINTERN double gum_ImportanceSampling_Sl_double_Sg__H__SWIG_0(gum::ImportanceSampling< double > *self,gum::NodeId const X){
     return self->gum::MarginalTargetedInference<double>::H(X);
   }
SWIGINTERN double gum_ImportanceSampling_Sl_double_Sg__H__SWIG_1(gum::ImportanceSampling< double > *self,std::string const &nodeName){
     return self->gum::MarginalTargetedInference<double>::H(nodeName);
   }
SWIGINTERN gum::Potential< double > gum_ImportanceSampling_Sl_double_Sg__evidenceImpact__SWIG_1(gum::ImportanceSampling< double > *self,std::string const &target,std::vector< std::string,std::allocator< std::string > > const &evs){
   return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Potential< double > const &gum_ImportanceSampling_Sl_double_Sg__currentPosterior__SWIG_0(gum::ImportanceSampling< double > *self,gum::NodeId const id){return self->gum::SamplingInference<double>::currentPosterior(id);}
SWIGINTERN gum::Potential< double > const &gum_ImportanceSampling_Sl_double_Sg__currentPosterior__SWIG_1(gum::ImportanceSampling< double > *self,std::string const &name){return self->gum::SamplingInference<double>::currentPosterior(name);}
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__setEvidence(gum::WeightedSampling< double > *self,PyObject *evidces){}
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__updateEvidence(gum::WeightedSampling< double > *self,PyObject *evidces){}
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__setTargets(gum::WeightedSampling< double > *self,PyObject *targets){}
SWIGINTERN PyObject *gum_WeightedSampling_Sl_double_Sg__hardEvidenceNodes(gum::WeightedSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_WeightedSampling_Sl_double_Sg__softEvidenceNodes(gum::WeightedSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_WeightedSampling_Sl_double_Sg__targets(gum::WeightedSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->targets() );
    }
SWIGINTERN gum::Potential< double > gum_WeightedSampling_Sl_double_Sg__evidenceImpact__SWIG_0(gum::WeightedSampling< double > *self,gum::NodeId target,PyObject *evs){
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN());
      return self->evidenceImpact(target,soe);
    }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__setVerbosity(gum::WeightedSampling< double > *self,bool v){ self->gum::ApproximationScheme::setVerbosity(v); }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__setEpsilon(gum::WeightedSampling< double > *self,double eps){ self->gum::ApproximationScheme::setEpsilon(eps); }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__setMinEpsilonRate(gum::WeightedSampling< double > *self,double rate){ self->gum::ApproximationScheme::setMinEpsilonRate(rate); }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__setMaxIter(gum::WeightedSampling< double > *self,gum::Size max){ self->gum::ApproximationScheme::setMaxIter(max); }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__setMaxTime(gum::WeightedSampling< double > *self,double timeout){ self->gum::ApproximationScheme::setMaxTime(timeout); }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__setPeriodSize(gum::WeightedSampling< double > *self,gum::Size p){ self->gum::ApproximationScheme::setPeriodSize(p); }
SWIGINTERN bool gum_WeightedSampling_Sl_double_Sg__verbosity(gum::WeightedSampling< double > const *self){ return self->gum::ApproximationScheme::verbosity(); }
SWIGINTERN double gum_WeightedSampling_Sl_double_Sg__epsilon(gum::WeightedSampling< double > const *self){ return self->gum::ApproximationScheme::epsilon(); }
SWIGINTERN double gum_WeightedSampling_Sl_double_Sg__minEpsilonRate(gum::WeightedSampling< double > const *self){ return self->gum::ApproximationScheme::minEpsilonRate(); }
SWIGINTERN gum::Size gum_WeightedSampling_Sl_double_Sg__maxIter(gum::WeightedSampling< double > const *self){ return self->gum::ApproximationScheme::maxIter(); }
SWIGINTERN double gum_WeightedSampling_Sl_double_Sg__maxTime(gum::WeightedSampling< double > const *self){ return self->gum::ApproximationScheme::maxTime(); }
SWIGINTERN gum::Size gum_WeightedSampling_Sl_double_Sg__periodSize(gum::WeightedSampling< double > const *self){ return self->gum::ApproximationScheme::periodSize(); }
SWIGINTERN gum::Size gum_WeightedSampling_Sl_double_Sg__nbrIterations(gum::WeightedSampling< double > const *self){ return self->gum::ApproximationScheme::nbrIterations(); }
SWIGINTERN double gum_WeightedSampling_Sl_double_Sg__currentTime(gum::WeightedSampling< double > const *self){ return self->gum::ApproximationScheme::currentTime(); }
SWIGINTERN std::string gum_WeightedSampling_Sl_double_Sg__messageApproximationScheme(gum::WeightedSampling< double > const *self){ return self->gum::ApproximationScheme::messageApproximationScheme(); }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_WeightedSampling_Sl_double_Sg__history(gum::WeightedSampling< double > const *self){ return self->gum::ApproximationScheme::history(); }
SWIGINTERN gum::IApproximationSchemeConfiguration const &gum_WeightedSampling_Sl_double_Sg__asIApproximationSchemeConfiguration(gum::WeightedSampling< double > const *self){
    return *(dynamic_cast<const gum::IApproximationSchemeConfiguration *>(self));
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__makeInference(gum::WeightedSampling< double > *self){
    self->gum::BayesNetInference<double>::makeInference();
  }
SWIGINTERN gum::Potential< double > const gum_WeightedSampling_Sl_double_Sg__posterior__SWIG_0(gum::WeightedSampling< double > *self,gum::NodeId const var){
    return self->MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Potential< double > const gum_WeightedSampling_Sl_double_Sg__posterior__SWIG_1(gum::WeightedSampling< double > *self,std::string const nodeName){
    return self->MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN gum::IBayesNet< double > const &gum_WeightedSampling_Sl_double_Sg__BN(gum::WeightedSampling< double > const *self){
    return self->BayesNetInference<double>::BN();
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__addEvidence__SWIG_0(gum::WeightedSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__addEvidence__SWIG_1(gum::WeightedSampling< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__addEvidence__SWIG_2(gum::WeightedSampling< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__addEvidence__SWIG_3(gum::WeightedSampling< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__addEvidence__SWIG_4(gum::WeightedSampling< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::addEvidence(id,vals);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__addEvidence__SWIG_5(gum::WeightedSampling< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_0(gum::WeightedSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_1(gum::WeightedSampling< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_2(gum::WeightedSampling< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_3(gum::WeightedSampling< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_4(gum::WeightedSampling< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_5(gum::WeightedSampling< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,vals);
  }
SWIGINTERN bool gum_WeightedSampling_Sl_double_Sg__hasEvidence__SWIG_0(gum::WeightedSampling< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasEvidence(id);
  }
SWIGINTERN bool gum_WeightedSampling_Sl_double_Sg__hasEvidence__SWIG_1(gum::WeightedSampling< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__eraseAllEvidence(gum::WeightedSampling< double > *self){
    self->gum::BayesNetInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__eraseEvidence__SWIG_0(gum::WeightedSampling< double > *self,gum::NodeId const id){
    self->gum::BayesNetInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__eraseEvidence__SWIG_1(gum::WeightedSampling< double > *self,std::string const &nodeName){
    self->gum::BayesNetInference<double>::eraseEvidence(nodeName);
  }
SWIGINTERN bool gum_WeightedSampling_Sl_double_Sg__hasSoftEvidence__SWIG_0(gum::WeightedSampling< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_WeightedSampling_Sl_double_Sg__hasHardEvidence(gum::WeightedSampling< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasHardEvidence(nodeName);
  }
SWIGINTERN bool gum_WeightedSampling_Sl_double_Sg__hasSoftEvidence__SWIG_1(gum::WeightedSampling< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_WeightedSampling_Sl_double_Sg__nbrEvidence(gum::WeightedSampling< double > const *self){
    return self->gum::BayesNetInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_WeightedSampling_Sl_double_Sg__nbrHardEvidence(gum::WeightedSampling< double > const *self){
    return self->gum::BayesNetInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_WeightedSampling_Sl_double_Sg__nbrSoftEvidence(gum::WeightedSampling< double > const *self){
    return self->gum::BayesNetInference<double>::nbrSoftEvidence();
  }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__eraseAllTargets(gum::WeightedSampling< double > *self){
      self->gum::MarginalTargetedInference<double>::eraseAllTargets();
    }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__addAllTargets(gum::WeightedSampling< double > *self){
      self->gum::MarginalTargetedInference<double>::addAllTargets();
    }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__addTarget__SWIG_0(gum::WeightedSampling< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::addTarget(target);
    }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__addTarget__SWIG_1(gum::WeightedSampling< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::addTarget(nodeName);
    }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__eraseTarget__SWIG_0(gum::WeightedSampling< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::eraseTarget(target);
    }
SWIGINTERN void gum_WeightedSampling_Sl_double_Sg__eraseTarget__SWIG_1(gum::WeightedSampling< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::eraseTarget(nodeName);
    }
SWIGINTERN bool gum_WeightedSampling_Sl_double_Sg__isTarget__SWIG_0(gum::WeightedSampling< double > const *self,gum::NodeId const variable){
      return self->gum::MarginalTargetedInference<double>::isTarget(variable);
    }
SWIGINTERN bool gum_WeightedSampling_Sl_double_Sg__isTarget__SWIG_1(gum::WeightedSampling< double > const *self,std::string const &nodeName){
      return self->gum::MarginalTargetedInference<double>::isTarget(nodeName);
    }
SWIGINTERN gum::Size gum_WeightedSampling_Sl_double_Sg__nbrTargets(gum::WeightedSampling< double > const *self){
      return self->gum::MarginalTargetedInference<double>::nbrTargets();
    }
SWIGINTERN double gum_WeightedSampling_Sl_double_Sg__H__SWIG_0(gum::WeightedSampling< double > *self,gum::NodeId const X){
     return self->gum::MarginalTargetedInference<double>::H(X);
   }
SWIGINTERN double gum_WeightedSampling_Sl_double_Sg__H__SWIG_1(gum::WeightedSampling< double > *self,std::string const &nodeName){
     return self->gum::MarginalTargetedInference<double>::H(nodeName);
   }
SWIGINTERN gum::Potential< double > gum_WeightedSampling_Sl_double_Sg__evidenceImpact__SWIG_1(gum::WeightedSampling< double > *self,std::string const &target,std::vector< std::string,std::allocator< std::string > > const &evs){
   return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Potential< double > const &gum_WeightedSampling_Sl_double_Sg__currentPosterior__SWIG_0(gum::WeightedSampling< double > *self,gum::NodeId const id){return self->gum::SamplingInference<double>::currentPosterior(id);}
SWIGINTERN gum::Potential< double > const &gum_WeightedSampling_Sl_double_Sg__currentPosterior__SWIG_1(gum::WeightedSampling< double > *self,std::string const &name){return self->gum::SamplingInference<double>::currentPosterior(name);}
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__setEvidence(gum::MonteCarloSampling< double > *self,PyObject *evidces){}
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__updateEvidence(gum::MonteCarloSampling< double > *self,PyObject *evidces){}
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__setTargets(gum::MonteCarloSampling< double > *self,PyObject *targets){}
SWIGINTERN PyObject *gum_MonteCarloSampling_Sl_double_Sg__hardEvidenceNodes(gum::MonteCarloSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_MonteCarloSampling_Sl_double_Sg__softEvidenceNodes(gum::MonteCarloSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_MonteCarloSampling_Sl_double_Sg__targets(gum::MonteCarloSampling< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->targets() );
    }
SWIGINTERN gum::Potential< double > gum_MonteCarloSampling_Sl_double_Sg__evidenceImpact__SWIG_0(gum::MonteCarloSampling< double > *self,gum::NodeId target,PyObject *evs){
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN());
      return self->evidenceImpact(target,soe);
    }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__setVerbosity(gum::MonteCarloSampling< double > *self,bool v){ self->gum::ApproximationScheme::setVerbosity(v); }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__setEpsilon(gum::MonteCarloSampling< double > *self,double eps){ self->gum::ApproximationScheme::setEpsilon(eps); }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__setMinEpsilonRate(gum::MonteCarloSampling< double > *self,double rate){ self->gum::ApproximationScheme::setMinEpsilonRate(rate); }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__setMaxIter(gum::MonteCarloSampling< double > *self,gum::Size max){ self->gum::ApproximationScheme::setMaxIter(max); }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__setMaxTime(gum::MonteCarloSampling< double > *self,double timeout){ self->gum::ApproximationScheme::setMaxTime(timeout); }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__setPeriodSize(gum::MonteCarloSampling< double > *self,gum::Size p){ self->gum::ApproximationScheme::setPeriodSize(p); }
SWIGINTERN bool gum_MonteCarloSampling_Sl_double_Sg__verbosity(gum::MonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::verbosity(); }
SWIGINTERN double gum_MonteCarloSampling_Sl_double_Sg__epsilon(gum::MonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::epsilon(); }
SWIGINTERN double gum_MonteCarloSampling_Sl_double_Sg__minEpsilonRate(gum::MonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::minEpsilonRate(); }
SWIGINTERN gum::Size gum_MonteCarloSampling_Sl_double_Sg__maxIter(gum::MonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::maxIter(); }
SWIGINTERN double gum_MonteCarloSampling_Sl_double_Sg__maxTime(gum::MonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::maxTime(); }
SWIGINTERN gum::Size gum_MonteCarloSampling_Sl_double_Sg__periodSize(gum::MonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::periodSize(); }
SWIGINTERN gum::Size gum_MonteCarloSampling_Sl_double_Sg__nbrIterations(gum::MonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::nbrIterations(); }
SWIGINTERN double gum_MonteCarloSampling_Sl_double_Sg__currentTime(gum::MonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::currentTime(); }
SWIGINTERN std::string gum_MonteCarloSampling_Sl_double_Sg__messageApproximationScheme(gum::MonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::messageApproximationScheme(); }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_MonteCarloSampling_Sl_double_Sg__history(gum::MonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::history(); }
SWIGINTERN gum::IApproximationSchemeConfiguration const &gum_MonteCarloSampling_Sl_double_Sg__asIApproximationSchemeConfiguration(gum::MonteCarloSampling< double > const *self){
    return *(dynamic_cast<const gum::IApproximationSchemeConfiguration *>(self));
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__makeInference(gum::MonteCarloSampling< double > *self){
    self->gum::BayesNetInference<double>::makeInference();
  }
SWIGINTERN gum::Potential< double > const gum_MonteCarloSampling_Sl_double_Sg__posterior__SWIG_0(gum::MonteCarloSampling< double > *self,gum::NodeId const var){
    return self->MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Potential< double > const gum_MonteCarloSampling_Sl_double_Sg__posterior__SWIG_1(gum::MonteCarloSampling< double > *self,std::string const nodeName){
    return self->MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN gum::IBayesNet< double > const &gum_MonteCarloSampling_Sl_double_Sg__BN(gum::MonteCarloSampling< double > const *self){
    return self->BayesNetInference<double>::BN();
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_0(gum::MonteCarloSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_1(gum::MonteCarloSampling< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_2(gum::MonteCarloSampling< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_3(gum::MonteCarloSampling< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_4(gum::MonteCarloSampling< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::addEvidence(id,vals);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_5(gum::MonteCarloSampling< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_0(gum::MonteCarloSampling< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_1(gum::MonteCarloSampling< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_2(gum::MonteCarloSampling< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_3(gum::MonteCarloSampling< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_4(gum::MonteCarloSampling< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_5(gum::MonteCarloSampling< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,vals);
  }
SWIGINTERN bool gum_MonteCarloSampling_Sl_double_Sg__hasEvidence__SWIG_0(gum::MonteCarloSampling< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasEvidence(id);
  }
SWIGINTERN bool gum_MonteCarloSampling_Sl_double_Sg__hasEvidence__SWIG_1(gum::MonteCarloSampling< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__eraseAllEvidence(gum::MonteCarloSampling< double > *self){
    self->gum::BayesNetInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__eraseEvidence__SWIG_0(gum::MonteCarloSampling< double > *self,gum::NodeId const id){
    self->gum::BayesNetInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__eraseEvidence__SWIG_1(gum::MonteCarloSampling< double > *self,std::string const &nodeName){
    self->gum::BayesNetInference<double>::eraseEvidence(nodeName);
  }
SWIGINTERN bool gum_MonteCarloSampling_Sl_double_Sg__hasSoftEvidence__SWIG_0(gum::MonteCarloSampling< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_MonteCarloSampling_Sl_double_Sg__hasHardEvidence(gum::MonteCarloSampling< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasHardEvidence(nodeName);
  }
SWIGINTERN bool gum_MonteCarloSampling_Sl_double_Sg__hasSoftEvidence__SWIG_1(gum::MonteCarloSampling< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_MonteCarloSampling_Sl_double_Sg__nbrEvidence(gum::MonteCarloSampling< double > const *self){
    return self->gum::BayesNetInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_MonteCarloSampling_Sl_double_Sg__nbrHardEvidence(gum::MonteCarloSampling< double > const *self){
    return self->gum::BayesNetInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_MonteCarloSampling_Sl_double_Sg__nbrSoftEvidence(gum::MonteCarloSampling< double > const *self){
    return self->gum::BayesNetInference<double>::nbrSoftEvidence();
  }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__eraseAllTargets(gum::MonteCarloSampling< double > *self){
      self->gum::MarginalTargetedInference<double>::eraseAllTargets();
    }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__addAllTargets(gum::MonteCarloSampling< double > *self){
      self->gum::MarginalTargetedInference<double>::addAllTargets();
    }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__addTarget__SWIG_0(gum::MonteCarloSampling< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::addTarget(target);
    }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__addTarget__SWIG_1(gum::MonteCarloSampling< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::addTarget(nodeName);
    }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__eraseTarget__SWIG_0(gum::MonteCarloSampling< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::eraseTarget(target);
    }
SWIGINTERN void gum_MonteCarloSampling_Sl_double_Sg__eraseTarget__SWIG_1(gum::MonteCarloSampling< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::eraseTarget(nodeName);
    }
SWIGINTERN bool gum_MonteCarloSampling_Sl_double_Sg__isTarget__SWIG_0(gum::MonteCarloSampling< double > const *self,gum::NodeId const variable){
      return self->gum::MarginalTargetedInference<double>::isTarget(variable);
    }
SWIGINTERN bool gum_MonteCarloSampling_Sl_double_Sg__isTarget__SWIG_1(gum::MonteCarloSampling< double > const *self,std::string const &nodeName){
      return self->gum::MarginalTargetedInference<double>::isTarget(nodeName);
    }
SWIGINTERN gum::Size gum_MonteCarloSampling_Sl_double_Sg__nbrTargets(gum::MonteCarloSampling< double > const *self){
      return self->gum::MarginalTargetedInference<double>::nbrTargets();
    }
SWIGINTERN double gum_MonteCarloSampling_Sl_double_Sg__H__SWIG_0(gum::MonteCarloSampling< double > *self,gum::NodeId const X){
     return self->gum::MarginalTargetedInference<double>::H(X);
   }
SWIGINTERN double gum_MonteCarloSampling_Sl_double_Sg__H__SWIG_1(gum::MonteCarloSampling< double > *self,std::string const &nodeName){
     return self->gum::MarginalTargetedInference<double>::H(nodeName);
   }
SWIGINTERN gum::Potential< double > gum_MonteCarloSampling_Sl_double_Sg__evidenceImpact__SWIG_1(gum::MonteCarloSampling< double > *self,std::string const &target,std::vector< std::string,std::allocator< std::string > > const &evs){
   return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Potential< double > const &gum_MonteCarloSampling_Sl_double_Sg__currentPosterior__SWIG_0(gum::MonteCarloSampling< double > *self,gum::NodeId const id){return self->gum::SamplingInference<double>::currentPosterior(id);}
SWIGINTERN gum::Potential< double > const &gum_MonteCarloSampling_Sl_double_Sg__currentPosterior__SWIG_1(gum::MonteCarloSampling< double > *self,std::string const &name){return self->gum::SamplingInference<double>::currentPosterior(name);}
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setEvidence(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,PyObject *evidces){}
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__updateEvidence(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,PyObject *evidces){}
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setTargets(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,PyObject *targets){}
SWIGINTERN PyObject *gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__hardEvidenceNodes(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__softEvidenceNodes(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__targets(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->targets() );
    }
SWIGINTERN gum::Potential< double > gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__evidenceImpact__SWIG_0(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::NodeId target,PyObject *evs){
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN());
      return self->evidenceImpact(target,soe);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setVerbosity(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,bool v){ self->gum::ApproximationScheme::setVerbosity(v); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setEpsilon(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,double eps){ self->gum::ApproximationScheme::setEpsilon(eps); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setMinEpsilonRate(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,double rate){ self->gum::ApproximationScheme::setMinEpsilonRate(rate); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setMaxIter(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::Size max){ self->gum::ApproximationScheme::setMaxIter(max); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setMaxTime(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,double timeout){ self->gum::ApproximationScheme::setMaxTime(timeout); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setPeriodSize(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::Size p){ self->gum::ApproximationScheme::setPeriodSize(p); }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__verbosity(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){ return self->gum::ApproximationScheme::verbosity(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__epsilon(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){ return self->gum::ApproximationScheme::epsilon(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__minEpsilonRate(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){ return self->gum::ApproximationScheme::minEpsilonRate(); }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__maxIter(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){ return self->gum::ApproximationScheme::maxIter(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__maxTime(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){ return self->gum::ApproximationScheme::maxTime(); }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__periodSize(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){ return self->gum::ApproximationScheme::periodSize(); }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__nbrIterations(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){ return self->gum::ApproximationScheme::nbrIterations(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__currentTime(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){ return self->gum::ApproximationScheme::currentTime(); }
SWIGINTERN std::string gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__messageApproximationScheme(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){ return self->gum::ApproximationScheme::messageApproximationScheme(); }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__history(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){ return self->gum::ApproximationScheme::history(); }
SWIGINTERN gum::IApproximationSchemeConfiguration const &gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__asIApproximationSchemeConfiguration(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){
    return *(dynamic_cast<const gum::IApproximationSchemeConfiguration *>(self));
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__makeInference(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self){
    self->gum::BayesNetInference<double>::makeInference();
  }
SWIGINTERN gum::Potential< double > const gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__posterior__SWIG_0(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::NodeId const var){
    return self->MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Potential< double > const gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__posterior__SWIG_1(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,std::string const nodeName){
    return self->MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN gum::IBayesNet< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__BN(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){
    return self->BayesNetInference<double>::BN();
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addEvidence__SWIG_2(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addEvidence__SWIG_3(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addEvidence__SWIG_4(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::addEvidence(id,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addEvidence__SWIG_5(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_2(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_3(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_4(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_5(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,vals);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__hasEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasEvidence(id);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__hasEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__eraseAllEvidence(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self){
    self->gum::BayesNetInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__eraseEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::NodeId const id){
    self->gum::BayesNetInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__eraseEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,std::string const &nodeName){
    self->gum::BayesNetInference<double>::eraseEvidence(nodeName);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__hasSoftEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__hasHardEvidence(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasHardEvidence(nodeName);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__hasSoftEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__nbrEvidence(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){
    return self->gum::BayesNetInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__nbrHardEvidence(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){
    return self->gum::BayesNetInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__nbrSoftEvidence(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){
    return self->gum::BayesNetInference<double>::nbrSoftEvidence();
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__eraseAllTargets(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self){
      self->gum::MarginalTargetedInference<double>::eraseAllTargets();
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addAllTargets(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self){
      self->gum::MarginalTargetedInference<double>::addAllTargets();
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addTarget__SWIG_0(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::addTarget(target);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addTarget__SWIG_1(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::addTarget(nodeName);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__eraseTarget__SWIG_0(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::eraseTarget(target);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__eraseTarget__SWIG_1(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::eraseTarget(nodeName);
    }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__isTarget__SWIG_0(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self,gum::NodeId const variable){
      return self->gum::MarginalTargetedInference<double>::isTarget(variable);
    }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__isTarget__SWIG_1(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self,std::string const &nodeName){
      return self->gum::MarginalTargetedInference<double>::isTarget(nodeName);
    }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__nbrTargets(gum::LoopySamplingInference< double,gum::ImportanceSampling > const *self){
      return self->gum::MarginalTargetedInference<double>::nbrTargets();
    }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__H__SWIG_0(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::NodeId const X){
     return self->gum::MarginalTargetedInference<double>::H(X);
   }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__H__SWIG_1(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,std::string const &nodeName){
     return self->gum::MarginalTargetedInference<double>::H(nodeName);
   }
SWIGINTERN gum::Potential< double > gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__evidenceImpact__SWIG_1(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,std::string const &target,std::vector< std::string,std::allocator< std::string > > const &evs){
   return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Potential< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__currentPosterior__SWIG_0(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,gum::NodeId const id){return self->gum::SamplingInference<double>::currentPosterior(id);}
SWIGINTERN gum::Potential< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__currentPosterior__SWIG_1(gum::LoopySamplingInference< double,gum::ImportanceSampling > *self,std::string const &name){return self->gum::SamplingInference<double>::currentPosterior(name);}
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setEvidence(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,PyObject *evidces){}
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__updateEvidence(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,PyObject *evidces){}
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setTargets(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,PyObject *targets){}
SWIGINTERN PyObject *gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__hardEvidenceNodes(gum::LoopySamplingInference< double,gum::WeightedSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__softEvidenceNodes(gum::LoopySamplingInference< double,gum::WeightedSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__targets(gum::LoopySamplingInference< double,gum::WeightedSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->targets() );
    }
SWIGINTERN gum::Potential< double > gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__evidenceImpact__SWIG_0(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::NodeId target,PyObject *evs){
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN());
      return self->evidenceImpact(target,soe);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setVerbosity(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,bool v){ self->gum::ApproximationScheme::setVerbosity(v); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setEpsilon(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,double eps){ self->gum::ApproximationScheme::setEpsilon(eps); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setMinEpsilonRate(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,double rate){ self->gum::ApproximationScheme::setMinEpsilonRate(rate); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setMaxIter(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::Size max){ self->gum::ApproximationScheme::setMaxIter(max); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setMaxTime(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,double timeout){ self->gum::ApproximationScheme::setMaxTime(timeout); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setPeriodSize(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::Size p){ self->gum::ApproximationScheme::setPeriodSize(p); }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__verbosity(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){ return self->gum::ApproximationScheme::verbosity(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__epsilon(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){ return self->gum::ApproximationScheme::epsilon(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__minEpsilonRate(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){ return self->gum::ApproximationScheme::minEpsilonRate(); }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__maxIter(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){ return self->gum::ApproximationScheme::maxIter(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__maxTime(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){ return self->gum::ApproximationScheme::maxTime(); }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__periodSize(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){ return self->gum::ApproximationScheme::periodSize(); }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__nbrIterations(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){ return self->gum::ApproximationScheme::nbrIterations(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__currentTime(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){ return self->gum::ApproximationScheme::currentTime(); }
SWIGINTERN std::string gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__messageApproximationScheme(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){ return self->gum::ApproximationScheme::messageApproximationScheme(); }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__history(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){ return self->gum::ApproximationScheme::history(); }
SWIGINTERN gum::IApproximationSchemeConfiguration const &gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__asIApproximationSchemeConfiguration(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){
    return *(dynamic_cast<const gum::IApproximationSchemeConfiguration *>(self));
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__makeInference(gum::LoopySamplingInference< double,gum::WeightedSampling > *self){
    self->gum::BayesNetInference<double>::makeInference();
  }
SWIGINTERN gum::Potential< double > const gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__posterior__SWIG_0(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::NodeId const var){
    return self->MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Potential< double > const gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__posterior__SWIG_1(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,std::string const nodeName){
    return self->MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN gum::IBayesNet< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__BN(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){
    return self->BayesNetInference<double>::BN();
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addEvidence__SWIG_2(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addEvidence__SWIG_3(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addEvidence__SWIG_4(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::addEvidence(id,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addEvidence__SWIG_5(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_2(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_3(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_4(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_5(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,vals);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__hasEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasEvidence(id);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__hasEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__eraseAllEvidence(gum::LoopySamplingInference< double,gum::WeightedSampling > *self){
    self->gum::BayesNetInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__eraseEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::NodeId const id){
    self->gum::BayesNetInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__eraseEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,std::string const &nodeName){
    self->gum::BayesNetInference<double>::eraseEvidence(nodeName);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__hasSoftEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__hasHardEvidence(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasHardEvidence(nodeName);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__hasSoftEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__nbrEvidence(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){
    return self->gum::BayesNetInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__nbrHardEvidence(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){
    return self->gum::BayesNetInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__nbrSoftEvidence(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){
    return self->gum::BayesNetInference<double>::nbrSoftEvidence();
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__eraseAllTargets(gum::LoopySamplingInference< double,gum::WeightedSampling > *self){
      self->gum::MarginalTargetedInference<double>::eraseAllTargets();
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addAllTargets(gum::LoopySamplingInference< double,gum::WeightedSampling > *self){
      self->gum::MarginalTargetedInference<double>::addAllTargets();
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addTarget__SWIG_0(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::addTarget(target);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addTarget__SWIG_1(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::addTarget(nodeName);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__eraseTarget__SWIG_0(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::eraseTarget(target);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__eraseTarget__SWIG_1(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::eraseTarget(nodeName);
    }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__isTarget__SWIG_0(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self,gum::NodeId const variable){
      return self->gum::MarginalTargetedInference<double>::isTarget(variable);
    }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__isTarget__SWIG_1(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self,std::string const &nodeName){
      return self->gum::MarginalTargetedInference<double>::isTarget(nodeName);
    }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__nbrTargets(gum::LoopySamplingInference< double,gum::WeightedSampling > const *self){
      return self->gum::MarginalTargetedInference<double>::nbrTargets();
    }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__H__SWIG_0(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::NodeId const X){
     return self->gum::MarginalTargetedInference<double>::H(X);
   }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__H__SWIG_1(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,std::string const &nodeName){
     return self->gum::MarginalTargetedInference<double>::H(nodeName);
   }
SWIGINTERN gum::Potential< double > gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__evidenceImpact__SWIG_1(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,std::string const &target,std::vector< std::string,std::allocator< std::string > > const &evs){
   return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Potential< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__currentPosterior__SWIG_0(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,gum::NodeId const id){return self->gum::SamplingInference<double>::currentPosterior(id);}
SWIGINTERN gum::Potential< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__currentPosterior__SWIG_1(gum::LoopySamplingInference< double,gum::WeightedSampling > *self,std::string const &name){return self->gum::SamplingInference<double>::currentPosterior(name);}
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setEvidence(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,PyObject *evidces){}
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__updateEvidence(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,PyObject *evidces){}
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setTargets(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,PyObject *targets){}
SWIGINTERN PyObject *gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__hardEvidenceNodes(gum::LoopySamplingInference< double,gum::GibbsSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__softEvidenceNodes(gum::LoopySamplingInference< double,gum::GibbsSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__targets(gum::LoopySamplingInference< double,gum::GibbsSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->targets() );
    }
SWIGINTERN gum::Potential< double > gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__evidenceImpact__SWIG_0(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::NodeId target,PyObject *evs){
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN());
      return self->evidenceImpact(target,soe);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setVerbosity(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,bool v){ self->gum::ApproximationScheme::setVerbosity(v); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setEpsilon(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,double eps){ self->gum::ApproximationScheme::setEpsilon(eps); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setMinEpsilonRate(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,double rate){ self->gum::ApproximationScheme::setMinEpsilonRate(rate); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setMaxIter(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::Size max){ self->gum::ApproximationScheme::setMaxIter(max); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setMaxTime(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,double timeout){ self->gum::ApproximationScheme::setMaxTime(timeout); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setPeriodSize(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::Size p){ self->gum::ApproximationScheme::setPeriodSize(p); }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__verbosity(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){ return self->gum::ApproximationScheme::verbosity(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__epsilon(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){ return self->gum::ApproximationScheme::epsilon(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__minEpsilonRate(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){ return self->gum::ApproximationScheme::minEpsilonRate(); }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__maxIter(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){ return self->gum::ApproximationScheme::maxIter(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__maxTime(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){ return self->gum::ApproximationScheme::maxTime(); }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__periodSize(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){ return self->gum::ApproximationScheme::periodSize(); }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__nbrIterations(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){ return self->gum::ApproximationScheme::nbrIterations(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__currentTime(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){ return self->gum::ApproximationScheme::currentTime(); }
SWIGINTERN std::string gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__messageApproximationScheme(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){ return self->gum::ApproximationScheme::messageApproximationScheme(); }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__history(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){ return self->gum::ApproximationScheme::history(); }
SWIGINTERN gum::IApproximationSchemeConfiguration const &gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__asIApproximationSchemeConfiguration(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){
    return *(dynamic_cast<const gum::IApproximationSchemeConfiguration *>(self));
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__makeInference(gum::LoopySamplingInference< double,gum::GibbsSampling > *self){
    self->gum::BayesNetInference<double>::makeInference();
  }
SWIGINTERN gum::Potential< double > const gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__posterior__SWIG_0(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::NodeId const var){
    return self->MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Potential< double > const gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__posterior__SWIG_1(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,std::string const nodeName){
    return self->MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN gum::IBayesNet< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__BN(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){
    return self->BayesNetInference<double>::BN();
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addEvidence__SWIG_2(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addEvidence__SWIG_3(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addEvidence__SWIG_4(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::addEvidence(id,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addEvidence__SWIG_5(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_2(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_3(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_4(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_5(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,vals);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__hasEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasEvidence(id);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__hasEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__eraseAllEvidence(gum::LoopySamplingInference< double,gum::GibbsSampling > *self){
    self->gum::BayesNetInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__eraseEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::NodeId const id){
    self->gum::BayesNetInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__eraseEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,std::string const &nodeName){
    self->gum::BayesNetInference<double>::eraseEvidence(nodeName);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__hasSoftEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__hasHardEvidence(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasHardEvidence(nodeName);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__hasSoftEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__nbrEvidence(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){
    return self->gum::BayesNetInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__nbrHardEvidence(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){
    return self->gum::BayesNetInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__nbrSoftEvidence(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){
    return self->gum::BayesNetInference<double>::nbrSoftEvidence();
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__eraseAllTargets(gum::LoopySamplingInference< double,gum::GibbsSampling > *self){
      self->gum::MarginalTargetedInference<double>::eraseAllTargets();
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addAllTargets(gum::LoopySamplingInference< double,gum::GibbsSampling > *self){
      self->gum::MarginalTargetedInference<double>::addAllTargets();
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addTarget__SWIG_0(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::addTarget(target);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addTarget__SWIG_1(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::addTarget(nodeName);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__eraseTarget__SWIG_0(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::eraseTarget(target);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__eraseTarget__SWIG_1(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::eraseTarget(nodeName);
    }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__isTarget__SWIG_0(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self,gum::NodeId const variable){
      return self->gum::MarginalTargetedInference<double>::isTarget(variable);
    }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__isTarget__SWIG_1(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self,std::string const &nodeName){
      return self->gum::MarginalTargetedInference<double>::isTarget(nodeName);
    }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__nbrTargets(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){
      return self->gum::MarginalTargetedInference<double>::nbrTargets();
    }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__H__SWIG_0(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::NodeId const X){
     return self->gum::MarginalTargetedInference<double>::H(X);
   }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__H__SWIG_1(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,std::string const &nodeName){
     return self->gum::MarginalTargetedInference<double>::H(nodeName);
   }
SWIGINTERN gum::Potential< double > gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__evidenceImpact__SWIG_1(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,std::string const &target,std::vector< std::string,std::allocator< std::string > > const &evs){
   return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Potential< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__currentPosterior__SWIG_0(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::NodeId const id){return self->gum::SamplingInference<double>::currentPosterior(id);}
SWIGINTERN gum::Potential< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__currentPosterior__SWIG_1(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,std::string const &name){return self->gum::SamplingInference<double>::currentPosterior(name);}
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__nbrDrawnVar(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){ return self->GibbsOperator<double>::nbrDrawnVar(); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setNbrDrawnVar(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::Size _nbr){ self->GibbsOperator<double>::setNbrDrawnVar(_nbr); }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__isDrawnAtRandom(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){ return self->GibbsOperator<double>::isDrawnAtRandom(); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setDrawnAtRandom(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,bool _atRandom){ self->GibbsOperator<double>::setDrawnAtRandom(_atRandom); }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__burnIn(gum::LoopySamplingInference< double,gum::GibbsSampling > const *self){ return self->gum::GibbsSampling<double>::burnIn();}
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setBurnIn(gum::LoopySamplingInference< double,gum::GibbsSampling > *self,gum::Size b){ self->gum::GibbsSampling<double>::setBurnIn(b);}
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setEvidence(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,PyObject *evidces){}
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__updateEvidence(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,PyObject *evidces){}
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setTargets(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,PyObject *targets){}
SWIGINTERN PyObject *gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__hardEvidenceNodes(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__softEvidenceNodes(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__targets(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->targets() );
    }
SWIGINTERN gum::Potential< double > gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__evidenceImpact__SWIG_0(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::NodeId target,PyObject *evs){
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN());
      return self->evidenceImpact(target,soe);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setVerbosity(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,bool v){ self->gum::ApproximationScheme::setVerbosity(v); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setEpsilon(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,double eps){ self->gum::ApproximationScheme::setEpsilon(eps); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setMinEpsilonRate(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,double rate){ self->gum::ApproximationScheme::setMinEpsilonRate(rate); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setMaxIter(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::Size max){ self->gum::ApproximationScheme::setMaxIter(max); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setMaxTime(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,double timeout){ self->gum::ApproximationScheme::setMaxTime(timeout); }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setPeriodSize(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::Size p){ self->gum::ApproximationScheme::setPeriodSize(p); }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__verbosity(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){ return self->gum::ApproximationScheme::verbosity(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__epsilon(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){ return self->gum::ApproximationScheme::epsilon(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__minEpsilonRate(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){ return self->gum::ApproximationScheme::minEpsilonRate(); }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__maxIter(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){ return self->gum::ApproximationScheme::maxIter(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__maxTime(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){ return self->gum::ApproximationScheme::maxTime(); }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__periodSize(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){ return self->gum::ApproximationScheme::periodSize(); }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__nbrIterations(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){ return self->gum::ApproximationScheme::nbrIterations(); }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__currentTime(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){ return self->gum::ApproximationScheme::currentTime(); }
SWIGINTERN std::string gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__messageApproximationScheme(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){ return self->gum::ApproximationScheme::messageApproximationScheme(); }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__history(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){ return self->gum::ApproximationScheme::history(); }
SWIGINTERN gum::IApproximationSchemeConfiguration const &gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__asIApproximationSchemeConfiguration(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){
    return *(dynamic_cast<const gum::IApproximationSchemeConfiguration *>(self));
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__makeInference(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self){
    self->gum::BayesNetInference<double>::makeInference();
  }
SWIGINTERN gum::Potential< double > const gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__posterior__SWIG_0(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::NodeId const var){
    return self->MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Potential< double > const gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__posterior__SWIG_1(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,std::string const nodeName){
    return self->MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN gum::IBayesNet< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__BN(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){
    return self->BayesNetInference<double>::BN();
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addEvidence__SWIG_2(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addEvidence__SWIG_3(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addEvidence__SWIG_4(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::addEvidence(id,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addEvidence__SWIG_5(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_2(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_3(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_4(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_5(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,vals);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__hasEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasEvidence(id);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__hasEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__eraseAllEvidence(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self){
    self->gum::BayesNetInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__eraseEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::NodeId const id){
    self->gum::BayesNetInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__eraseEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,std::string const &nodeName){
    self->gum::BayesNetInference<double>::eraseEvidence(nodeName);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__hasSoftEvidence__SWIG_0(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__hasHardEvidence(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasHardEvidence(nodeName);
  }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__hasSoftEvidence__SWIG_1(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__nbrEvidence(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){
    return self->gum::BayesNetInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__nbrHardEvidence(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){
    return self->gum::BayesNetInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__nbrSoftEvidence(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){
    return self->gum::BayesNetInference<double>::nbrSoftEvidence();
  }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__eraseAllTargets(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self){
      self->gum::MarginalTargetedInference<double>::eraseAllTargets();
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addAllTargets(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self){
      self->gum::MarginalTargetedInference<double>::addAllTargets();
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addTarget__SWIG_0(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::addTarget(target);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addTarget__SWIG_1(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::addTarget(nodeName);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__eraseTarget__SWIG_0(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::eraseTarget(target);
    }
SWIGINTERN void gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__eraseTarget__SWIG_1(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::eraseTarget(nodeName);
    }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__isTarget__SWIG_0(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self,gum::NodeId const variable){
      return self->gum::MarginalTargetedInference<double>::isTarget(variable);
    }
SWIGINTERN bool gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__isTarget__SWIG_1(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self,std::string const &nodeName){
      return self->gum::MarginalTargetedInference<double>::isTarget(nodeName);
    }
SWIGINTERN gum::Size gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__nbrTargets(gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *self){
      return self->gum::MarginalTargetedInference<double>::nbrTargets();
    }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__H__SWIG_0(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::NodeId const X){
     return self->gum::MarginalTargetedInference<double>::H(X);
   }
SWIGINTERN double gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__H__SWIG_1(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,std::string const &nodeName){
     return self->gum::MarginalTargetedInference<double>::H(nodeName);
   }
SWIGINTERN gum::Potential< double > gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__evidenceImpact__SWIG_1(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,std::string const &target,std::vector< std::string,std::allocator< std::string > > const &evs){
   return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN gum::Potential< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__currentPosterior__SWIG_0(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,gum::NodeId const id){return self->gum::SamplingInference<double>::currentPosterior(id);}
SWIGINTERN gum::Potential< double > const &gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__currentPosterior__SWIG_1(gum::LoopySamplingInference< double,gum::MonteCarloSampling > *self,std::string const &name){return self->gum::SamplingInference<double>::currentPosterior(name);}
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__setEvidence(gum::LoopyBeliefPropagation< double > *self,PyObject *evidces){}
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__updateEvidence(gum::LoopyBeliefPropagation< double > *self,PyObject *evidces){}
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__setTargets(gum::LoopyBeliefPropagation< double > *self,PyObject *targets){}
SWIGINTERN PyObject *gum_LoopyBeliefPropagation_Sl_double_Sg__hardEvidenceNodes(gum::LoopyBeliefPropagation< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->hardEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_LoopyBeliefPropagation_Sl_double_Sg__softEvidenceNodes(gum::LoopyBeliefPropagation< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->softEvidenceNodes() ) ;
    }
SWIGINTERN PyObject *gum_LoopyBeliefPropagation_Sl_double_Sg__targets(gum::LoopyBeliefPropagation< double > *self){
      return PyAgrumHelper::PySetFromNodeSet(self->targets() );
    }
SWIGINTERN gum::Potential< double > gum_LoopyBeliefPropagation_Sl_double_Sg__evidenceImpact__SWIG_0(gum::LoopyBeliefPropagation< double > *self,gum::NodeId target,PyObject *evs){
      gum::NodeSet soe;
      PyAgrumHelper::populateNodeSetFromPySequenceOfIntOrString(soe,evs,self->BN());
      return self->evidenceImpact(target,soe);
    }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__setVerbosity(gum::LoopyBeliefPropagation< double > *self,bool v){ self->gum::ApproximationScheme::setVerbosity(v); }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__setEpsilon(gum::LoopyBeliefPropagation< double > *self,double eps){ self->gum::ApproximationScheme::setEpsilon(eps); }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__setMinEpsilonRate(gum::LoopyBeliefPropagation< double > *self,double rate){ self->gum::ApproximationScheme::setMinEpsilonRate(rate); }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__setMaxIter(gum::LoopyBeliefPropagation< double > *self,gum::Size max){ self->gum::ApproximationScheme::setMaxIter(max); }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__setMaxTime(gum::LoopyBeliefPropagation< double > *self,double timeout){ self->gum::ApproximationScheme::setMaxTime(timeout); }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__setPeriodSize(gum::LoopyBeliefPropagation< double > *self,gum::Size p){ self->gum::ApproximationScheme::setPeriodSize(p); }
SWIGINTERN bool gum_LoopyBeliefPropagation_Sl_double_Sg__verbosity(gum::LoopyBeliefPropagation< double > const *self){ return self->gum::ApproximationScheme::verbosity(); }
SWIGINTERN double gum_LoopyBeliefPropagation_Sl_double_Sg__epsilon(gum::LoopyBeliefPropagation< double > const *self){ return self->gum::ApproximationScheme::epsilon(); }
SWIGINTERN double gum_LoopyBeliefPropagation_Sl_double_Sg__minEpsilonRate(gum::LoopyBeliefPropagation< double > const *self){ return self->gum::ApproximationScheme::minEpsilonRate(); }
SWIGINTERN gum::Size gum_LoopyBeliefPropagation_Sl_double_Sg__maxIter(gum::LoopyBeliefPropagation< double > const *self){ return self->gum::ApproximationScheme::maxIter(); }
SWIGINTERN double gum_LoopyBeliefPropagation_Sl_double_Sg__maxTime(gum::LoopyBeliefPropagation< double > const *self){ return self->gum::ApproximationScheme::maxTime(); }
SWIGINTERN gum::Size gum_LoopyBeliefPropagation_Sl_double_Sg__periodSize(gum::LoopyBeliefPropagation< double > const *self){ return self->gum::ApproximationScheme::periodSize(); }
SWIGINTERN gum::Size gum_LoopyBeliefPropagation_Sl_double_Sg__nbrIterations(gum::LoopyBeliefPropagation< double > const *self){ return self->gum::ApproximationScheme::nbrIterations(); }
SWIGINTERN double gum_LoopyBeliefPropagation_Sl_double_Sg__currentTime(gum::LoopyBeliefPropagation< double > const *self){ return self->gum::ApproximationScheme::currentTime(); }
SWIGINTERN std::string gum_LoopyBeliefPropagation_Sl_double_Sg__messageApproximationScheme(gum::LoopyBeliefPropagation< double > const *self){ return self->gum::ApproximationScheme::messageApproximationScheme(); }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_LoopyBeliefPropagation_Sl_double_Sg__history(gum::LoopyBeliefPropagation< double > const *self){ return self->gum::ApproximationScheme::history(); }
SWIGINTERN gum::IApproximationSchemeConfiguration const &gum_LoopyBeliefPropagation_Sl_double_Sg__asIApproximationSchemeConfiguration(gum::LoopyBeliefPropagation< double > const *self){
    return *(dynamic_cast<const gum::IApproximationSchemeConfiguration *>(self));
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__makeInference(gum::LoopyBeliefPropagation< double > *self){
    self->gum::BayesNetInference<double>::makeInference();
  }
SWIGINTERN gum::Potential< double > const gum_LoopyBeliefPropagation_Sl_double_Sg__posterior__SWIG_0(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const var){
    return self->MarginalTargetedInference<double>::posterior(var);
  }
SWIGINTERN gum::Potential< double > const gum_LoopyBeliefPropagation_Sl_double_Sg__posterior__SWIG_1(gum::LoopyBeliefPropagation< double > *self,std::string const nodeName){
    return self->MarginalTargetedInference<double>::posterior(nodeName);
  }
SWIGINTERN gum::IBayesNet< double > const &gum_LoopyBeliefPropagation_Sl_double_Sg__BN(gum::LoopyBeliefPropagation< double > const *self){
    return self->BayesNetInference<double>::BN();
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__addEvidence__SWIG_0(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__addEvidence__SWIG_1(gum::LoopyBeliefPropagation< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__addEvidence__SWIG_2(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(id,val);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__addEvidence__SWIG_3(gum::LoopyBeliefPropagation< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__addEvidence__SWIG_4(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::addEvidence(id,vals);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__addEvidence__SWIG_5(gum::LoopyBeliefPropagation< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::addEvidence(nodeName,vals);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_0(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const id,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_1(gum::LoopyBeliefPropagation< double > *self,std::string const &nodeName,gum::Idx const val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_2(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const id,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(id,val);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_3(gum::LoopyBeliefPropagation< double > *self,std::string const &nodeName,std::string const &val){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,val);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_4(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const id,std::vector< double,std::allocator< double > > const &vals){
   self->gum::BayesNetInference<double>::chgEvidence(id,vals);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_5(gum::LoopyBeliefPropagation< double > *self,std::string const &nodeName,std::vector< double,std::allocator< double > > const &vals){
    self->gum::BayesNetInference<double>::chgEvidence(nodeName,vals);
  }
SWIGINTERN bool gum_LoopyBeliefPropagation_Sl_double_Sg__hasEvidence__SWIG_0(gum::LoopyBeliefPropagation< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasEvidence(id);
  }
SWIGINTERN bool gum_LoopyBeliefPropagation_Sl_double_Sg__hasEvidence__SWIG_1(gum::LoopyBeliefPropagation< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasEvidence(nodeName);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__eraseAllEvidence(gum::LoopyBeliefPropagation< double > *self){
    self->gum::BayesNetInference<double>::eraseAllEvidence();
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__eraseEvidence__SWIG_0(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const id){
    self->gum::BayesNetInference<double>::eraseEvidence(id);
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__eraseEvidence__SWIG_1(gum::LoopyBeliefPropagation< double > *self,std::string const &nodeName){
    self->gum::BayesNetInference<double>::eraseEvidence(nodeName);
  }
SWIGINTERN bool gum_LoopyBeliefPropagation_Sl_double_Sg__hasSoftEvidence__SWIG_0(gum::LoopyBeliefPropagation< double > const *self,gum::NodeId const id){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(id);
  }
SWIGINTERN bool gum_LoopyBeliefPropagation_Sl_double_Sg__hasHardEvidence(gum::LoopyBeliefPropagation< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasHardEvidence(nodeName);
  }
SWIGINTERN bool gum_LoopyBeliefPropagation_Sl_double_Sg__hasSoftEvidence__SWIG_1(gum::LoopyBeliefPropagation< double > const *self,std::string const &nodeName){
    return self->gum::BayesNetInference<double>::hasSoftEvidence(nodeName);
  }
SWIGINTERN gum::Size gum_LoopyBeliefPropagation_Sl_double_Sg__nbrEvidence(gum::LoopyBeliefPropagation< double > const *self){
    return self->gum::BayesNetInference<double>::nbrEvidence();
  }
SWIGINTERN gum::Size gum_LoopyBeliefPropagation_Sl_double_Sg__nbrHardEvidence(gum::LoopyBeliefPropagation< double > const *self){
    return self->gum::BayesNetInference<double>::nbrHardEvidence();
  }
SWIGINTERN gum::Size gum_LoopyBeliefPropagation_Sl_double_Sg__nbrSoftEvidence(gum::LoopyBeliefPropagation< double > const *self){
    return self->gum::BayesNetInference<double>::nbrSoftEvidence();
  }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__eraseAllTargets(gum::LoopyBeliefPropagation< double > *self){
      self->gum::MarginalTargetedInference<double>::eraseAllTargets();
    }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__addAllTargets(gum::LoopyBeliefPropagation< double > *self){
      self->gum::MarginalTargetedInference<double>::addAllTargets();
    }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__addTarget__SWIG_0(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::addTarget(target);
    }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__addTarget__SWIG_1(gum::LoopyBeliefPropagation< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::addTarget(nodeName);
    }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__eraseTarget__SWIG_0(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const target){
      self->gum::MarginalTargetedInference<double>::eraseTarget(target);
    }
SWIGINTERN void gum_LoopyBeliefPropagation_Sl_double_Sg__eraseTarget__SWIG_1(gum::LoopyBeliefPropagation< double > *self,std::string const &nodeName){
      self->gum::MarginalTargetedInference<double>::eraseTarget(nodeName);
    }
SWIGINTERN bool gum_LoopyBeliefPropagation_Sl_double_Sg__isTarget__SWIG_0(gum::LoopyBeliefPropagation< double > const *self,gum::NodeId const variable){
      return self->gum::MarginalTargetedInference<double>::isTarget(variable);
    }
SWIGINTERN bool gum_LoopyBeliefPropagation_Sl_double_Sg__isTarget__SWIG_1(gum::LoopyBeliefPropagation< double > const *self,std::string const &nodeName){
      return self->gum::MarginalTargetedInference<double>::isTarget(nodeName);
    }
SWIGINTERN gum::Size gum_LoopyBeliefPropagation_Sl_double_Sg__nbrTargets(gum::LoopyBeliefPropagation< double > const *self){
      return self->gum::MarginalTargetedInference<double>::nbrTargets();
    }
SWIGINTERN double gum_LoopyBeliefPropagation_Sl_double_Sg__H__SWIG_0(gum::LoopyBeliefPropagation< double > *self,gum::NodeId const X){
     return self->gum::MarginalTargetedInference<double>::H(X);
   }
SWIGINTERN double gum_LoopyBeliefPropagation_Sl_double_Sg__H__SWIG_1(gum::LoopyBeliefPropagation< double > *self,std::string const &nodeName){
     return self->gum::MarginalTargetedInference<double>::H(nodeName);
   }
SWIGINTERN gum::Potential< double > gum_LoopyBeliefPropagation_Sl_double_Sg__evidenceImpact__SWIG_1(gum::LoopyBeliefPropagation< double > *self,std::string const &target,std::vector< std::string,std::allocator< std::string > > const &evs){
   return self->gum::MarginalTargetedInference<double>::evidenceImpact(target,evs);
  }
SWIGINTERN PyObject *gum_ExactBNdistance_Sl_double_Sg__compute(gum::ExactBNdistance< double > *self){
  PyObject* q=PyDict_New();

  PyDict_SetItemString(q,"klPQ",PyFloat_FromDouble(self->klPQ()));
  PyDict_SetItemString(q,"errorPQ",PyInt_FromLong(self->errorPQ()));
  PyDict_SetItemString(q,"klQP",PyFloat_FromDouble(self->klQP()));
  PyDict_SetItemString(q,"errorQP",PyInt_FromLong(self->errorQP()));
  PyDict_SetItemString(q,"hellinger",PyFloat_FromDouble(self->hellinger()));
  PyDict_SetItemString(q,"bhattacharya",PyFloat_FromDouble(self->bhattacharya()));
  PyDict_SetItemString(q,"jensen-shannon",PyFloat_FromDouble(self->jsd()));

  return q;
}
SWIGINTERN PyObject *gum_GibbsBNdistance_Sl_double_Sg__compute(gum::GibbsBNdistance< double > *self){
  PyObject* q=PyDict_New();

  PyDict_SetItemString(q,"klPQ",PyFloat_FromDouble(self->klPQ()));
  PyDict_SetItemString(q,"errorPQ",PyInt_FromLong(self->errorPQ()));
  PyDict_SetItemString(q,"klQP",PyFloat_FromDouble(self->klQP()));
  PyDict_SetItemString(q,"errorQP",PyInt_FromLong(self->errorQP()));
  PyDict_SetItemString(q,"hellinger",PyFloat_FromDouble(self->hellinger()));
  PyDict_SetItemString(q,"bhattacharya",PyFloat_FromDouble(self->bhattacharya()));
  PyDict_SetItemString(q,"jensen-shannon",PyFloat_FromDouble(self->jsd()));

  return q;
}
SWIGINTERN void gum_GibbsBNdistance_Sl_double_Sg__setVerbosity(gum::GibbsBNdistance< double > *self,bool v){ self->gum::ApproximationScheme::setVerbosity(v); }
SWIGINTERN void gum_GibbsBNdistance_Sl_double_Sg__setEpsilon(gum::GibbsBNdistance< double > *self,double eps){ self->gum::ApproximationScheme::setEpsilon(eps); }
SWIGINTERN void gum_GibbsBNdistance_Sl_double_Sg__setMinEpsilonRate(gum::GibbsBNdistance< double > *self,double rate){ self->gum::ApproximationScheme::setMinEpsilonRate(rate); }
SWIGINTERN void gum_GibbsBNdistance_Sl_double_Sg__setMaxIter(gum::GibbsBNdistance< double > *self,gum::Size max){ self->gum::ApproximationScheme::setMaxIter(max); }
SWIGINTERN void gum_GibbsBNdistance_Sl_double_Sg__setMaxTime(gum::GibbsBNdistance< double > *self,double timeout){ self->gum::ApproximationScheme::setMaxTime(timeout); }
SWIGINTERN void gum_GibbsBNdistance_Sl_double_Sg__setPeriodSize(gum::GibbsBNdistance< double > *self,gum::Size p){ self->gum::ApproximationScheme::setPeriodSize(p); }
SWIGINTERN bool gum_GibbsBNdistance_Sl_double_Sg__verbosity(gum::GibbsBNdistance< double > const *self){ return self->gum::ApproximationScheme::verbosity(); }
SWIGINTERN double gum_GibbsBNdistance_Sl_double_Sg__epsilon(gum::GibbsBNdistance< double > const *self){ return self->gum::ApproximationScheme::epsilon(); }
SWIGINTERN double gum_GibbsBNdistance_Sl_double_Sg__minEpsilonRate(gum::GibbsBNdistance< double > const *self){ return self->gum::ApproximationScheme::minEpsilonRate(); }
SWIGINTERN gum::Size gum_GibbsBNdistance_Sl_double_Sg__maxIter(gum::GibbsBNdistance< double > const *self){ return self->gum::ApproximationScheme::maxIter(); }
SWIGINTERN double gum_GibbsBNdistance_Sl_double_Sg__maxTime(gum::GibbsBNdistance< double > const *self){ return self->gum::ApproximationScheme::maxTime(); }
SWIGINTERN gum::Size gum_GibbsBNdistance_Sl_double_Sg__periodSize(gum::GibbsBNdistance< double > const *self){ return self->gum::ApproximationScheme::periodSize(); }
SWIGINTERN gum::Size gum_GibbsBNdistance_Sl_double_Sg__nbrIterations(gum::GibbsBNdistance< double > const *self){ return self->gum::ApproximationScheme::nbrIterations(); }
SWIGINTERN double gum_GibbsBNdistance_Sl_double_Sg__currentTime(gum::GibbsBNdistance< double > const *self){ return self->gum::ApproximationScheme::currentTime(); }
SWIGINTERN std::string gum_GibbsBNdistance_Sl_double_Sg__messageApproximationScheme(gum::GibbsBNdistance< double > const *self){ return self->gum::ApproximationScheme::messageApproximationScheme(); }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_GibbsBNdistance_Sl_double_Sg__history(gum::GibbsBNdistance< double > const *self){ return self->gum::ApproximationScheme::history(); }
SWIGINTERN gum::IApproximationSchemeConfiguration const &gum_GibbsBNdistance_Sl_double_Sg__asIApproximationSchemeConfiguration(gum::GibbsBNdistance< double > const *self){
    return *(dynamic_cast<const gum::IApproximationSchemeConfiguration *>(self));
  }
SWIGINTERN gum::Size gum_GibbsBNdistance_Sl_double_Sg__nbrDrawnVar(gum::GibbsBNdistance< double > const *self){ return self->GibbsOperator<double>::nbrDrawnVar(); }
SWIGINTERN void gum_GibbsBNdistance_Sl_double_Sg__setNbrDrawnVar(gum::GibbsBNdistance< double > *self,gum::Size _nbr){ self->GibbsOperator<double>::setNbrDrawnVar(_nbr); }
SWIGINTERN bool gum_GibbsBNdistance_Sl_double_Sg__isDrawnAtRandom(gum::GibbsBNdistance< double > const *self){ return self->GibbsOperator<double>::isDrawnAtRandom(); }
SWIGINTERN void gum_GibbsBNdistance_Sl_double_Sg__setDrawnAtRandom(gum::GibbsBNdistance< double > *self,bool _atRandom){ self->GibbsOperator<double>::setDrawnAtRandom(_atRandom); }
SWIGINTERN std::string gum_credal_CredalNet_Sl_double_Sg____repr__(gum::credal::CredalNet< double > const *self){
   std::stringstream s;
   s<<"(gum::credal::CredalNet<double>@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_credal_CredalNet_Sl_double_Sg____str__(gum::credal::CredalNet< double > const *self){ return self->toString();}
SWIGINTERN void gum_credal_CNMonteCarloSampling_Sl_double_Sg__setVerbosity(gum::credal::CNMonteCarloSampling< double > *self,bool v){ self->gum::ApproximationScheme::setVerbosity(v); }
SWIGINTERN void gum_credal_CNMonteCarloSampling_Sl_double_Sg__setEpsilon(gum::credal::CNMonteCarloSampling< double > *self,double eps){ self->gum::ApproximationScheme::setEpsilon(eps); }
SWIGINTERN void gum_credal_CNMonteCarloSampling_Sl_double_Sg__setMinEpsilonRate(gum::credal::CNMonteCarloSampling< double > *self,double rate){ self->gum::ApproximationScheme::setMinEpsilonRate(rate); }
SWIGINTERN void gum_credal_CNMonteCarloSampling_Sl_double_Sg__setMaxIter(gum::credal::CNMonteCarloSampling< double > *self,gum::Size max){ self->gum::ApproximationScheme::setMaxIter(max); }
SWIGINTERN void gum_credal_CNMonteCarloSampling_Sl_double_Sg__setMaxTime(gum::credal::CNMonteCarloSampling< double > *self,double timeout){ self->gum::ApproximationScheme::setMaxTime(timeout); }
SWIGINTERN void gum_credal_CNMonteCarloSampling_Sl_double_Sg__setPeriodSize(gum::credal::CNMonteCarloSampling< double > *self,gum::Size p){ self->gum::ApproximationScheme::setPeriodSize(p); }
SWIGINTERN bool gum_credal_CNMonteCarloSampling_Sl_double_Sg__verbosity(gum::credal::CNMonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::verbosity(); }
SWIGINTERN double gum_credal_CNMonteCarloSampling_Sl_double_Sg__epsilon(gum::credal::CNMonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::epsilon(); }
SWIGINTERN double gum_credal_CNMonteCarloSampling_Sl_double_Sg__minEpsilonRate(gum::credal::CNMonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::minEpsilonRate(); }
SWIGINTERN gum::Size gum_credal_CNMonteCarloSampling_Sl_double_Sg__maxIter(gum::credal::CNMonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::maxIter(); }
SWIGINTERN double gum_credal_CNMonteCarloSampling_Sl_double_Sg__maxTime(gum::credal::CNMonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::maxTime(); }
SWIGINTERN gum::Size gum_credal_CNMonteCarloSampling_Sl_double_Sg__periodSize(gum::credal::CNMonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::periodSize(); }
SWIGINTERN gum::Size gum_credal_CNMonteCarloSampling_Sl_double_Sg__nbrIterations(gum::credal::CNMonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::nbrIterations(); }
SWIGINTERN double gum_credal_CNMonteCarloSampling_Sl_double_Sg__currentTime(gum::credal::CNMonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::currentTime(); }
SWIGINTERN std::string gum_credal_CNMonteCarloSampling_Sl_double_Sg__messageApproximationScheme(gum::credal::CNMonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::messageApproximationScheme(); }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_credal_CNMonteCarloSampling_Sl_double_Sg__history(gum::credal::CNMonteCarloSampling< double > const *self){ return self->gum::ApproximationScheme::history(); }
SWIGINTERN gum::IApproximationSchemeConfiguration const &gum_credal_CNMonteCarloSampling_Sl_double_Sg__asIApproximationSchemeConfiguration(gum::credal::CNMonteCarloSampling< double > const *self){
    return *(dynamic_cast<const gum::IApproximationSchemeConfiguration *>(self));
  }
SWIGINTERN void gum_credal_CNMonteCarloSampling_Sl_double_Sg__setRepetitiveInd(gum::credal::CNMonteCarloSampling< double > *self,bool const flag){
    self->gum::credal::InferenceEngine<double>::setRepetitiveInd(flag);
  }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_credal_CNMonteCarloSampling_Sl_double_Sg__marginalMax__SWIG_0(gum::credal::CNMonteCarloSampling< double > const *self,gum::NodeId const id){
    return self->gum::credal::InferenceEngine<double>::marginalMax(id);
  }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_credal_CNMonteCarloSampling_Sl_double_Sg__marginalMin__SWIG_0(gum::credal::CNMonteCarloSampling< double > const *self,gum::NodeId const id){
    return self->gum::credal::InferenceEngine<double>::marginalMin(id);
  }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_credal_CNMonteCarloSampling_Sl_double_Sg__marginalMax__SWIG_1(gum::credal::CNMonteCarloSampling< double > const *self,std::string const name){
    return self->gum::credal::InferenceEngine<double>::marginalMax(name);
  }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_credal_CNMonteCarloSampling_Sl_double_Sg__marginalMin__SWIG_1(gum::credal::CNMonteCarloSampling< double > const *self,std::string const name){
    return self->gum::credal::InferenceEngine<double>::marginalMin(name);
  }
SWIGINTERN void gum_credal_CNMonteCarloSampling_Sl_double_Sg__insertModalsFile(gum::credal::CNMonteCarloSampling< double > *self,std::string const &path){
    self->gum::credal::InferenceEngine<double>::insertModalsFile(path);
  }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_credal_CNMonteCarloSampling_Sl_double_Sg__dynamicExpMax(gum::credal::CNMonteCarloSampling< double > const *self,std::string const &varName){
    return self->gum::credal::InferenceEngine<double>::dynamicExpMax(varName);
  }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_credal_CNMonteCarloSampling_Sl_double_Sg__dynamicExpMin(gum::credal::CNMonteCarloSampling< double > const *self,std::string const &varName){
    return self->gum::credal::InferenceEngine<double>::dynamicExpMin(varName);
  }
SWIGINTERN void gum_credal_CNLoopyPropagation_Sl_double_Sg__setVerbosity(gum::credal::CNLoopyPropagation< double > *self,bool v){ self->gum::ApproximationScheme::setVerbosity(v); }
SWIGINTERN void gum_credal_CNLoopyPropagation_Sl_double_Sg__setEpsilon(gum::credal::CNLoopyPropagation< double > *self,double eps){ self->gum::ApproximationScheme::setEpsilon(eps); }
SWIGINTERN void gum_credal_CNLoopyPropagation_Sl_double_Sg__setMinEpsilonRate(gum::credal::CNLoopyPropagation< double > *self,double rate){ self->gum::ApproximationScheme::setMinEpsilonRate(rate); }
SWIGINTERN void gum_credal_CNLoopyPropagation_Sl_double_Sg__setMaxIter(gum::credal::CNLoopyPropagation< double > *self,gum::Size max){ self->gum::ApproximationScheme::setMaxIter(max); }
SWIGINTERN void gum_credal_CNLoopyPropagation_Sl_double_Sg__setMaxTime(gum::credal::CNLoopyPropagation< double > *self,double timeout){ self->gum::ApproximationScheme::setMaxTime(timeout); }
SWIGINTERN void gum_credal_CNLoopyPropagation_Sl_double_Sg__setPeriodSize(gum::credal::CNLoopyPropagation< double > *self,gum::Size p){ self->gum::ApproximationScheme::setPeriodSize(p); }
SWIGINTERN bool gum_credal_CNLoopyPropagation_Sl_double_Sg__verbosity(gum::credal::CNLoopyPropagation< double > const *self){ return self->gum::ApproximationScheme::verbosity(); }
SWIGINTERN double gum_credal_CNLoopyPropagation_Sl_double_Sg__epsilon(gum::credal::CNLoopyPropagation< double > const *self){ return self->gum::ApproximationScheme::epsilon(); }
SWIGINTERN double gum_credal_CNLoopyPropagation_Sl_double_Sg__minEpsilonRate(gum::credal::CNLoopyPropagation< double > const *self){ return self->gum::ApproximationScheme::minEpsilonRate(); }
SWIGINTERN gum::Size gum_credal_CNLoopyPropagation_Sl_double_Sg__maxIter(gum::credal::CNLoopyPropagation< double > const *self){ return self->gum::ApproximationScheme::maxIter(); }
SWIGINTERN double gum_credal_CNLoopyPropagation_Sl_double_Sg__maxTime(gum::credal::CNLoopyPropagation< double > const *self){ return self->gum::ApproximationScheme::maxTime(); }
SWIGINTERN gum::Size gum_credal_CNLoopyPropagation_Sl_double_Sg__periodSize(gum::credal::CNLoopyPropagation< double > const *self){ return self->gum::ApproximationScheme::periodSize(); }
SWIGINTERN gum::Size gum_credal_CNLoopyPropagation_Sl_double_Sg__nbrIterations(gum::credal::CNLoopyPropagation< double > const *self){ return self->gum::ApproximationScheme::nbrIterations(); }
SWIGINTERN double gum_credal_CNLoopyPropagation_Sl_double_Sg__currentTime(gum::credal::CNLoopyPropagation< double > const *self){ return self->gum::ApproximationScheme::currentTime(); }
SWIGINTERN std::string gum_credal_CNLoopyPropagation_Sl_double_Sg__messageApproximationScheme(gum::credal::CNLoopyPropagation< double > const *self){ return self->gum::ApproximationScheme::messageApproximationScheme(); }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_credal_CNLoopyPropagation_Sl_double_Sg__history(gum::credal::CNLoopyPropagation< double > const *self){ return self->gum::ApproximationScheme::history(); }
SWIGINTERN gum::IApproximationSchemeConfiguration const &gum_credal_CNLoopyPropagation_Sl_double_Sg__asIApproximationSchemeConfiguration(gum::credal::CNLoopyPropagation< double > const *self){
    return *(dynamic_cast<const gum::IApproximationSchemeConfiguration *>(self));
  }
SWIGINTERN void gum_credal_CNLoopyPropagation_Sl_double_Sg__setRepetitiveInd(gum::credal::CNLoopyPropagation< double > *self,bool const flag){
    self->gum::credal::InferenceEngine<double>::setRepetitiveInd(flag);
  }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_credal_CNLoopyPropagation_Sl_double_Sg__marginalMax__SWIG_0(gum::credal::CNLoopyPropagation< double > const *self,gum::NodeId const id){
    return self->gum::credal::InferenceEngine<double>::marginalMax(id);
  }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_credal_CNLoopyPropagation_Sl_double_Sg__marginalMin__SWIG_0(gum::credal::CNLoopyPropagation< double > const *self,gum::NodeId const id){
    return self->gum::credal::InferenceEngine<double>::marginalMin(id);
  }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_credal_CNLoopyPropagation_Sl_double_Sg__marginalMax__SWIG_1(gum::credal::CNLoopyPropagation< double > const *self,std::string const name){
    return self->gum::credal::InferenceEngine<double>::marginalMax(name);
  }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_credal_CNLoopyPropagation_Sl_double_Sg__marginalMin__SWIG_1(gum::credal::CNLoopyPropagation< double > const *self,std::string const name){
    return self->gum::credal::InferenceEngine<double>::marginalMin(name);
  }
SWIGINTERN void gum_credal_CNLoopyPropagation_Sl_double_Sg__insertModalsFile(gum::credal::CNLoopyPropagation< double > *self,std::string const &path){
    self->gum::credal::InferenceEngine<double>::insertModalsFile(path);
  }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_credal_CNLoopyPropagation_Sl_double_Sg__dynamicExpMax(gum::credal::CNLoopyPropagation< double > const *self,std::string const &varName){
    return self->gum::credal::InferenceEngine<double>::dynamicExpMax(varName);
  }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_credal_CNLoopyPropagation_Sl_double_Sg__dynamicExpMin(gum::credal::CNLoopyPropagation< double > const *self,std::string const &varName){
    return self->gum::credal::InferenceEngine<double>::dynamicExpMin(varName);
  }
SWIGINTERN PyObject *gum_InfluenceDiagram_Sl_double_Sg__names(gum::InfluenceDiagram< double > const *self){
      PyObject* q=PyList_New(0);

      const gum::DAG& dag=self->dag();
      for ( gum::NodeGraphPartIterator node_iter = dag.nodes().begin();node_iter != dag.nodes().end(); ++node_iter ) {
        PyList_Append(q,PyString_FromString(self->variable(*node_iter).name().c_str()));
      }
      return q;
    }
SWIGINTERN PyObject *gum_InfluenceDiagram_Sl_double_Sg__ids(gum::InfluenceDiagram< double > *self){
      PyObject* q=PyList_New(0);

      const gum::DAG& dag=self->dag();
      for ( gum::NodeGraphPartIterator  node_iter = dag.nodes().begin();node_iter != dag.nodes().end(); ++node_iter ) {
        PyList_Append(q,PyInt_FromLong(*node_iter));
      }

      return q;
    }
SWIGINTERN PyObject *gum_InfluenceDiagram_Sl_double_Sg__arcs(gum::InfluenceDiagram< double > *self){
      PyObject* q=PyList_New(0);

      const gum::DAG& dag=self->dag();
      for ( auto arc_iter = dag.arcs().begin();arc_iter != dag.arcs().end(); ++arc_iter ) {
        PyList_Append(q,Py_BuildValue("(i,i)", arc_iter->tail(), arc_iter->head()));
      }

      return q;
    }
SWIGINTERN PyObject *gum_InfluenceDiagram_Sl_double_Sg__parents(gum::InfluenceDiagram< double > const *self,gum::NodeId const id){
    PyObject* q=PyList_New(0);

    const gum::NodeSet& p=self->dag().parents(id);
    for(gum::NodeSet::const_iterator it=p.begin();it!=p.end();++it) {
      PyList_Append(q,PyInt_FromLong(*it));
    }

    return q;
  }
SWIGINTERN PyObject *gum_InfluenceDiagram_Sl_double_Sg__children(gum::InfluenceDiagram< double > const *self,gum::NodeId const id){
    PyObject* q=PyList_New(0);

    const gum::NodeSet& p=self->dag().children(id);
    for(gum::NodeSet::const_iterator it=p.begin();it!=p.end();++it) {
      PyList_Append(q,PyInt_FromLong(*it));
    }

    return q;
  }
SWIGINTERN bool gum_InfluenceDiagram_Sl_double_Sg__loadBIFXML__SWIG_0(gum::InfluenceDiagram< double > *self,std::string name,PyObject *l=(PyObject *) 0){
    try {
        gum::BIFXMLIDReader<double> reader(self,name);
        reader.proceed(); 
        return true;
    } catch (gum::IOError& e) {
        throw(e);
    }

    return false;
  }
SWIGINTERN void gum_InfluenceDiagram_Sl_double_Sg__saveBIFXML(gum::InfluenceDiagram< double > *self,std::string name){
      gum::BIFXMLIDWriter<double> writer;
      writer.write( name, *self );
  }
SWIGINTERN std::string gum_InfluenceDiagram_Sl_double_Sg____repr__(gum::InfluenceDiagram< double > const *self){
   std::stringstream s;
   s<<"(gum::InfluenceDiagram<double>@"<<std::hex<<self<<") "<<self->toString();
   return s.str();
  }
SWIGINTERN std::string gum_InfluenceDiagram_Sl_double_Sg____str__(gum::InfluenceDiagram< double > const *self){ return self->toString();}
SWIGINTERN gum::InfluenceDiagram< double > const &gum_InfluenceDiagramInference_Sl_double_Sg__influenceDiagram(gum::InfluenceDiagramInference< double > const *self){
      return static_cast<const gum::IInfluenceDiagramInference<double> *>(self)->influenceDiagram();
    }
SWIGINTERN void gum_InfluenceDiagramInference_Sl_double_Sg__setEvidence(gum::InfluenceDiagramInference< double > *self,PyObject *evidces){}
SWIGINTERN void gum_InfluenceDiagramInference_Sl_double_Sg___setEvidence(gum::InfluenceDiagramInference< double > *self,PyObject *evidences){
      if (PySequence_Check(evidences)==0) {
        PyErr_SetString(PyExc_TypeError, "arg must be a sequence");
        return;
      }
      gum::List<const gum::Potential<double>* > l;

      for(Py_ssize_t i=0;i<PySequence_Size(evidences);i++) {
        PyObject* pot=PyList_GetItem(evidences, i);

	void *argp1 = 0 ;
	int res1 = 0 ;
	res1 = SWIG_ConvertPtr(pot, &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
	if (!SWIG_IsOK(res1)) {
	  PyErr_SetString(PyExc_TypeError,"Elements of arg must be Potentials");
	  return;
	}
	gum::Potential< double > *arg1 =  reinterpret_cast< gum::Potential< double > * >(argp1);
	l.push_front(arg1);
      }
      self->insertEvidence(l);
    }
SWIGINTERN std::string const gum_InfluenceDiagramInference_Sl_double_Sg__junctionTreeToDot(gum::InfluenceDiagramInference< double > *self){
      std::stringstream stream;
      self->displayStrongJunctionTree(stream);
      return stream.str();
    }
SWIGINTERN PyObject *gum_learning_BNLearner_Sl_double_Sg__chi2__SWIG_0(gum::learning::BNLearner< double > *self,std::string const &var1,std::string const &var2,std::vector< std::string,std::allocator< std::string > > const &knw={}){
    std::pair<double,double> res=self->chi2(var1,var2,knw);
    return Py_BuildValue("(dd)",res.first,res.second);
  }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setSliceOrder__SWIG_0(gum::learning::BNLearner< double > *self,PyObject *l){
    gum::NodeProperty< gum::Size > ranks;

    if (PyList_Check(l) == 0) {
      PyErr_SetString(PyExc_TypeError,
                      "arg must be a sequence (of sequences of int or string)");
      return;
    }

    for (Py_ssize_t i = 0; i < PySequence_Size(l); i++) {
      PyObject* rows = PyList_GetItem(l, i);
      if (PyList_Check(rows) == 0) {
        PyErr_SetString(PyExc_TypeError,
                        "arg must be a sequence of sequences (of int or string)");
        return;
      }

      for (Py_ssize_t j = 0; j < PySequence_Size(rows); j++) {
        PyObject* row = PyList_GetItem(rows, j);
        if (PyInt_Check(row) != 0) {
          ranks.insert(PyInt_AsLong(row), i);
          continue;
        }
        std::string n=PyAgrumHelper::stringFromPyObject(row);
        if (n!="") {
          ranks.insert(self->idFromName(n),i);
          continue;
        }

        PyErr_SetString(PyExc_TypeError,
                        "arg must be a sequence of sequence of int or string");
        return;
      }
    }
    self->setSliceOrder(ranks);
  }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useK2__SWIG_0(gum::learning::BNLearner< double > *self,PyObject *l){
    std::vector< gum::NodeId > v;

    if (PyList_Check(l) == 0) {
      PyErr_SetString(PyExc_TypeError, "arg must be a sequence");
      return;
    }

    for (Py_ssize_t i = 0; i < PySequence_Size(l); i++) {
      PyObject* row = PyList_GetItem(l, i);
      if (PyInt_Check(row) == 0) {
        PyErr_SetString(PyExc_TypeError, "arg must be a sequence of int");
        return;
      }
      v.push_back((gum::NodeId)PyInt_AsLong(row));
    }

    self->useK2(v);
  }
SWIGINTERN PyObject *gum_learning_BNLearner_Sl_double_Sg__latentVariables__SWIG_0(gum::learning::BNLearner< double > *self){
    return PyAgrumHelper::PyListFromArcVect(self->latentVariables());
  }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setVerbosity(gum::learning::BNLearner< double > *self,bool v){ self->gum::learning::genericBNLearner::setVerbosity(v); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setEpsilon(gum::learning::BNLearner< double > *self,double eps){ self->gum::learning::genericBNLearner::setEpsilon(eps); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setMinEpsilonRate(gum::learning::BNLearner< double > *self,double rate){ self->gum::learning::genericBNLearner::setMinEpsilonRate(rate); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setMaxIter(gum::learning::BNLearner< double > *self,gum::Size max){ self->gum::learning::genericBNLearner::setMaxIter(max); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setMaxTime__SWIG_0_0(gum::learning::BNLearner< double > *self,double timeout){ self->gum::learning::genericBNLearner::setMaxTime(timeout); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setPeriodSize(gum::learning::BNLearner< double > *self,gum::Size p){ self->gum::learning::genericBNLearner::setPeriodSize(p); }
SWIGINTERN bool gum_learning_BNLearner_Sl_double_Sg__verbosity(gum::learning::BNLearner< double > const *self){ return self->gum::learning::genericBNLearner::verbosity(); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__epsilon(gum::learning::BNLearner< double > const *self){ return self->gum::learning::genericBNLearner::epsilon(); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__minEpsilonRate(gum::learning::BNLearner< double > const *self){ return self->gum::learning::genericBNLearner::minEpsilonRate(); }
SWIGINTERN gum::Size gum_learning_BNLearner_Sl_double_Sg__maxIter(gum::learning::BNLearner< double > const *self){ return self->gum::learning::genericBNLearner::maxIter(); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__maxTime__SWIG_0_0(gum::learning::BNLearner< double > const *self){ return self->gum::learning::genericBNLearner::maxTime(); }
SWIGINTERN gum::Size gum_learning_BNLearner_Sl_double_Sg__periodSize(gum::learning::BNLearner< double > const *self){ return self->gum::learning::genericBNLearner::periodSize(); }
SWIGINTERN gum::Size gum_learning_BNLearner_Sl_double_Sg__nbrIterations(gum::learning::BNLearner< double > const *self){ return self->gum::learning::genericBNLearner::nbrIterations(); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__currentTime__SWIG_0_0(gum::learning::BNLearner< double > const *self){ return self->gum::learning::genericBNLearner::currentTime(); }
SWIGINTERN std::string gum_learning_BNLearner_Sl_double_Sg__messageApproximationScheme(gum::learning::BNLearner< double > const *self){ return self->gum::learning::genericBNLearner::messageApproximationScheme(); }
SWIGINTERN std::vector< double,std::allocator< double > > const &gum_learning_BNLearner_Sl_double_Sg__history(gum::learning::BNLearner< double > const *self){ return self->gum::learning::genericBNLearner::history(); }
SWIGINTERN gum::IApproximationSchemeConfiguration const &gum_learning_BNLearner_Sl_double_Sg__asIApproximationSchemeConfiguration(gum::learning::BNLearner< double > const *self){
    return *(dynamic_cast<const gum::IApproximationSchemeConfiguration *>(self));
  }
SWIGINTERN gum::DAG gum_learning_BNLearner_Sl_double_Sg__learnDAG(gum::learning::BNLearner< double > *self){ return self->gum::learning::genericBNLearner::learnDAG(); }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > const &gum_learning_BNLearner_Sl_double_Sg__names(gum::learning::BNLearner< double > const *self){ return self->gum::learning::genericBNLearner::names(); }
SWIGINTERN gum::NodeId gum_learning_BNLearner_Sl_double_Sg__idFromName(gum::learning::BNLearner< double > const *self,std::string const &var_name){ return self->gum::learning::genericBNLearner::idFromName(var_name); }
SWIGINTERN std::string const &gum_learning_BNLearner_Sl_double_Sg__nameFromId(gum::learning::BNLearner< double > const *self,gum::NodeId id){ return self->gum::learning::genericBNLearner::nameFromId(id); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useScoreAIC(gum::learning::BNLearner< double > *self){ self->gum::learning::genericBNLearner::useScoreAIC(); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useScoreBD(gum::learning::BNLearner< double > *self){ self->gum::learning::genericBNLearner::useScoreBD(); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useScoreBDeu(gum::learning::BNLearner< double > *self){ self->gum::learning::genericBNLearner::useScoreBDeu(); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useScoreBIC(gum::learning::BNLearner< double > *self){ self->gum::learning::genericBNLearner::useScoreBIC(); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useScoreK2(gum::learning::BNLearner< double > *self){ self->gum::learning::genericBNLearner::useScoreK2(); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useScoreLog2Likelihood(gum::learning::BNLearner< double > *self){ self->gum::learning::genericBNLearner::useScoreLog2Likelihood(); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setDatabaseWeight(gum::learning::BNLearner< double > *self,double const new_weight){ self->gum::learning::genericBNLearner::setDatabaseWeight(new_weight); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useNoApriori(gum::learning::BNLearner< double > *self){ self->gum::learning::genericBNLearner::useNoApriori(); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useAprioriSmoothing_SWIG_0_0(gum::learning::BNLearner< double > *self,double weight=1){ self->gum::learning::genericBNLearner::useAprioriSmoothing(weight); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useAprioriSmoothing_SWIG_0_1(gum::learning::BNLearner< double > *self){ self->gum::learning::genericBNLearner::useAprioriSmoothing(); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useAprioriDirichlet_SWIG_0_0(gum::learning::BNLearner< double > *self,std::string const &filename,double weight=1){ self->gum::learning::genericBNLearner::useAprioriDirichlet(filename,weight); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useAprioriDirichlet_SWIG_0_1(gum::learning::BNLearner< double > *self,std::string const &filename){ self->gum::learning::genericBNLearner::useAprioriDirichlet(filename); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useAprioriBDeu_SWIG_0_0(gum::learning::BNLearner< double > *self,double weight=1){ self->gum::learning::genericBNLearner::useAprioriBDeu(weight); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useAprioriBDeu_SWIG_0_1(gum::learning::BNLearner< double > *self){ self->gum::learning::genericBNLearner::useAprioriBDeu(); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useGreedyHillClimbing(gum::learning::BNLearner< double > *self){ self->gum::learning::genericBNLearner::useGreedyHillClimbing(); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useLocalSearchWithTabuList_SWIG_0_0(gum::learning::BNLearner< double > *self,gum::Size tabu_size=100,gum::Size nb_decrease=2){ self->gum::learning::genericBNLearner::useLocalSearchWithTabuList(tabu_size,nb_decrease); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useLocalSearchWithTabuList_SWIG_0_1(gum::learning::BNLearner< double > *self,gum::Size tabu_size=100){ self->gum::learning::genericBNLearner::useLocalSearchWithTabuList(tabu_size); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useLocalSearchWithTabuList_SWIG_0_2(gum::learning::BNLearner< double > *self){ self->gum::learning::genericBNLearner::useLocalSearchWithTabuList(); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useK2__SWIG_1_0(gum::learning::BNLearner< double > *self,gum::Sequence< gum::NodeId > const &order){ self->gum::learning::genericBNLearner::useK2(order); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useK2__SWIG_1_1(gum::learning::BNLearner< double > *self,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &order){ self->gum::learning::genericBNLearner::useK2(order); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setMaxIndegree(gum::learning::BNLearner< double > *self,gum::Size max_indegree){ self->gum::learning::genericBNLearner::setMaxIndegree(max_indegree); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setSliceOrder__SWIG_1_0(gum::learning::BNLearner< double > *self,gum::NodeProperty< gum::NodeId > const &slice_order){ self->gum::learning::genericBNLearner::setSliceOrder(slice_order); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setSliceOrder__SWIG_1_1(gum::learning::BNLearner< double > *self,std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const &slices){ self->gum::learning::genericBNLearner::setSliceOrder(slices); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__addForbiddenArc_SWIG_0_0(gum::learning::BNLearner< double > *self,gum::Arc const &arc){ self->gum::learning::genericBNLearner::addForbiddenArc(arc); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__addForbiddenArc_SWIG_0_1(gum::learning::BNLearner< double > *self,gum::NodeId const tail,gum::NodeId const head){ self->gum::learning::genericBNLearner::addForbiddenArc(tail,head); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__addForbiddenArc_SWIG_0_2(gum::learning::BNLearner< double > *self,std::string const &tail,std::string const &head){ self->gum::learning::genericBNLearner::addForbiddenArc(tail,head); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__eraseForbiddenArc_SWIG_0_0(gum::learning::BNLearner< double > *self,gum::Arc const &arc){ self->gum::learning::genericBNLearner::eraseForbiddenArc(arc); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__eraseForbiddenArc_SWIG_0_1(gum::learning::BNLearner< double > *self,gum::NodeId const tail,gum::NodeId const head){ self->gum::learning::genericBNLearner::eraseForbiddenArc(tail,head); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__eraseForbiddenArc_SWIG_0_2(gum::learning::BNLearner< double > *self,std::string const &tail,std::string const &head){ self->gum::learning::genericBNLearner::eraseForbiddenArc(tail,head); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__addMandatoryArc__SWIG_0_0(gum::learning::BNLearner< double > *self,gum::Arc const &arc){ self->gum::learning::genericBNLearner::addMandatoryArc(arc); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__addMandatoryArc__SWIG_0_1(gum::learning::BNLearner< double > *self,gum::NodeId const tail,gum::NodeId const head){ self->gum::learning::genericBNLearner::addMandatoryArc(tail,head); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__addMandatoryArc__SWIG_0_2(gum::learning::BNLearner< double > *self,std::string const &tail,std::string const &head){ self->gum::learning::genericBNLearner::addMandatoryArc(tail,head); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__eraseMandatoryArc_SWIG_0_0(gum::learning::BNLearner< double > *self,gum::Arc const &arc){ self->gum::learning::genericBNLearner::eraseMandatoryArc(arc); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__eraseMandatoryArc_SWIG_0_1(gum::learning::BNLearner< double > *self,gum::NodeId const tail,gum::NodeId const head){ self->gum::learning::genericBNLearner::eraseMandatoryArc(tail,head); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__eraseMandatoryArc_SWIG_0_2(gum::learning::BNLearner< double > *self,std::string const &tail,std::string const &head){ self->gum::learning::genericBNLearner::eraseMandatoryArc(tail,head); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useEM(gum::learning::BNLearner< double > *self,double const epsilon){ self->gum::learning::genericBNLearner::useEM(epsilon); }
SWIGINTERN bool gum_learning_BNLearner_Sl_double_Sg__hasMissingValues(gum::learning::BNLearner< double > const *self){ return self->gum::learning::genericBNLearner::hasMissingValues(); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__logLikelihood_SWIG_0_0(gum::learning::BNLearner< double > *self,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &vars,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &knowing={}){ return self->gum::learning::genericBNLearner::logLikelihood(vars,knowing); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__logLikelihood_SWIG_0_1(gum::learning::BNLearner< double > *self,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &vars){ return self->gum::learning::genericBNLearner::logLikelihood(vars); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__logLikelihood_SWIG_0_2(gum::learning::BNLearner< double > *self,std::vector< std::string,std::allocator< std::string > > const &vars,std::vector< std::string,std::allocator< std::string > > const &knowing={}){ return self->gum::learning::genericBNLearner::logLikelihood(vars,knowing); }
SWIGINTERN double gum_learning_BNLearner_Sl_double_Sg__logLikelihood_SWIG_0_3(gum::learning::BNLearner< double > *self,std::vector< std::string,std::allocator< std::string > > const &vars){ return self->gum::learning::genericBNLearner::logLikelihood(vars); }
SWIGINTERN gum::Size gum_learning_BNLearner_Sl_double_Sg__nbRows(gum::learning::BNLearner< double > const *self){ return self->gum::learning::genericBNLearner::nbRows(); }
SWIGINTERN gum::Size gum_learning_BNLearner_Sl_double_Sg__nbCols(gum::learning::BNLearner< double > const *self){ return self->gum::learning::genericBNLearner::nbCols(); }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__setInitialDAG(gum::learning::BNLearner< double > *self,gum::DAG const &g){
    self->gum::learning::genericBNLearner::setInitialDAG(g);
  }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__use3off2(gum::learning::BNLearner< double > *self){
    self->gum::learning::genericBNLearner::use3off2();
  }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useMIIC(gum::learning::BNLearner< double > *self){
    self->gum::learning::genericBNLearner::useMIIC();
  }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useNML(gum::learning::BNLearner< double > *self){
    self->gum::learning::genericBNLearner::useNML();
  }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useMDL(gum::learning::BNLearner< double > *self){
    self->gum::learning::genericBNLearner::useMDL();
  }
SWIGINTERN void gum_learning_BNLearner_Sl_double_Sg__useNoCorr(gum::learning::BNLearner< double > *self){
    self->gum::learning::genericBNLearner::useNoCorr();
  }
SWIGINTERN std::vector< gum::Arc,std::allocator< gum::Arc > > const gum_learning_BNLearner_Sl_double_Sg__latentVariables__SWIG_1(gum::learning::BNLearner< double > *self){
    return self->gum::learning::genericBNLearner::latentVariables();
  }
SWIGINTERN gum::MixedGraph gum_learning_BNLearner_Sl_double_Sg__learnMixedStructure(gum::learning::BNLearner< double > *self){
    return self->gum::learning::genericBNLearner::learnMixedStructure();
  }

namespace gum {
  void statsObj(void) {
#ifdef GUM_DEBUG_MODE
    gum::__debug__::__atexit();
#else
    //std::cout<<"Stats on aGrUM objects only available in debug mode"<<std::endl;
#endif // GUM_DEBUG_MODE
  }
}



/* ---------------------------------------------------
 * C++ director class methods
 * --------------------------------------------------- */

#include "pyAgrumPYTHON_wrap.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 *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_incr", 0, 2, argv))) SWIG_fail;
  --argc;
  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, argc, argv);
    }
  }
  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, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("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), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail;
  --argc;
  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, argc, argv);
    }
  }
  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, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("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 *swig_obj[2] ;
  ptrdiff_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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 *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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 *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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 *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


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 *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


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 *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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 *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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 *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  ptrdiff_t result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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(swig_obj[1], &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:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
  --argc;
  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, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
      }
    }
  }
  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, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


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

SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_junctionTree__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::UndiGraph *arg2 = 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__UndiGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::UndiGraph * >(argp2);
  arg3 = swig_obj[2];
  {
    try {
      result = ((JunctionTreeGenerator const *)arg1)->junctionTree((gum::UndiGraph const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::JunctionTree(static_cast< const gum::JunctionTree& >(result))), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_junctionTree__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::UndiGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__UndiGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::UndiGraph * >(argp2);
  {
    try {
      result = ((JunctionTreeGenerator const *)arg1)->junctionTree((gum::UndiGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::JunctionTree(static_cast< const gum::JunctionTree& >(result))), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_junctionTree__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::DAG *arg2 = 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DAG,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DAG * >(argp2);
  arg3 = swig_obj[2];
  {
    try {
      result = ((JunctionTreeGenerator const *)arg1)->junctionTree((gum::DAG const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::JunctionTree(static_cast< const gum::JunctionTree& >(result))), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_junctionTree__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::DAG *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DAG,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DAG * >(argp2);
  {
    try {
      result = ((JunctionTreeGenerator const *)arg1)->junctionTree((gum::DAG const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::JunctionTree(static_cast< const gum::JunctionTree& >(result))), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_junctionTree__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::BayesNet< double > * >(argp2);
  arg3 = swig_obj[2];
  {
    try {
      result = ((JunctionTreeGenerator const *)arg1)->junctionTree((gum::BayesNet< double > const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::JunctionTree(static_cast< const gum::JunctionTree& >(result))), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_junctionTree__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_junctionTree" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::BayesNet< double > * >(argp2);
  {
    try {
      result = ((JunctionTreeGenerator const *)arg1)->junctionTree((gum::BayesNet< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::JunctionTree(static_cast< const gum::JunctionTree& >(result))), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_junctionTree(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "JunctionTreeGenerator_junctionTree", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_JunctionTreeGenerator_junctionTree__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_JunctionTreeGenerator_junctionTree__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_JunctionTreeGenerator_junctionTree__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_JunctionTreeGenerator_junctionTree__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_JunctionTreeGenerator_junctionTree__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_JunctionTreeGenerator_junctionTree__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JunctionTreeGenerator_junctionTree'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    JunctionTreeGenerator::junctionTree(gum::UndiGraph const &,PyObject *) const\n"
    "    JunctionTreeGenerator::junctionTree(gum::UndiGraph const &) const\n"
    "    JunctionTreeGenerator::junctionTree(gum::DAG const &,PyObject *) const\n"
    "    JunctionTreeGenerator::junctionTree(gum::DAG const &) const\n"
    "    JunctionTreeGenerator::junctionTree(gum::BayesNet< double > const &,PyObject *) const\n"
    "    JunctionTreeGenerator::junctionTree(gum::BayesNet< double > const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_eliminationOrder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::UndiGraph *arg2 = 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__UndiGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::UndiGraph * >(argp2);
  arg3 = swig_obj[2];
  {
    try {
      result = (PyObject *)((JunctionTreeGenerator const *)arg1)->eliminationOrder((gum::UndiGraph const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_eliminationOrder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::UndiGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__UndiGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::UndiGraph * >(argp2);
  {
    try {
      result = (PyObject *)((JunctionTreeGenerator const *)arg1)->eliminationOrder((gum::UndiGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_eliminationOrder__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::DAG *arg2 = 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DAG,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DAG * >(argp2);
  arg3 = swig_obj[2];
  {
    try {
      result = (PyObject *)((JunctionTreeGenerator const *)arg1)->eliminationOrder((gum::DAG const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_eliminationOrder__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::DAG *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DAG,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DAG * >(argp2);
  {
    try {
      result = (PyObject *)((JunctionTreeGenerator const *)arg1)->eliminationOrder((gum::DAG const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_eliminationOrder__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::BayesNet< double > * >(argp2);
  arg3 = swig_obj[2];
  {
    try {
      result = (PyObject *)((JunctionTreeGenerator const *)arg1)->eliminationOrder((gum::BayesNet< double > const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_eliminationOrder__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_eliminationOrder" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::BayesNet< double > * >(argp2);
  {
    try {
      result = (PyObject *)((JunctionTreeGenerator const *)arg1)->eliminationOrder((gum::BayesNet< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_eliminationOrder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "JunctionTreeGenerator_eliminationOrder", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_JunctionTreeGenerator_eliminationOrder__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_JunctionTreeGenerator_eliminationOrder__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_JunctionTreeGenerator_eliminationOrder__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_JunctionTreeGenerator_eliminationOrder__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_JunctionTreeGenerator_eliminationOrder__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_JunctionTreeGenerator_eliminationOrder__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JunctionTreeGenerator_eliminationOrder'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    JunctionTreeGenerator::eliminationOrder(gum::UndiGraph const &,PyObject *) const\n"
    "    JunctionTreeGenerator::eliminationOrder(gum::UndiGraph const &) const\n"
    "    JunctionTreeGenerator::eliminationOrder(gum::DAG const &,PyObject *) const\n"
    "    JunctionTreeGenerator::eliminationOrder(gum::DAG const &) const\n"
    "    JunctionTreeGenerator::eliminationOrder(gum::BayesNet< double > const &,PyObject *) const\n"
    "    JunctionTreeGenerator::eliminationOrder(gum::BayesNet< double > const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::UndiGraph *arg2 = 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__UndiGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::UndiGraph * >(argp2);
  arg3 = swig_obj[2];
  {
    try {
      result = ((JunctionTreeGenerator const *)arg1)->binaryJoinTree((gum::UndiGraph const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::JunctionTree(static_cast< const gum::JunctionTree& >(result))), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::UndiGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__UndiGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::UndiGraph * >(argp2);
  {
    try {
      result = ((JunctionTreeGenerator const *)arg1)->binaryJoinTree((gum::UndiGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::JunctionTree(static_cast< const gum::JunctionTree& >(result))), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::DAG *arg2 = 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DAG,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DAG * >(argp2);
  arg3 = swig_obj[2];
  {
    try {
      result = ((JunctionTreeGenerator const *)arg1)->binaryJoinTree((gum::DAG const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::JunctionTree(static_cast< const gum::JunctionTree& >(result))), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::DAG *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DAG,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DAG * >(argp2);
  {
    try {
      result = ((JunctionTreeGenerator const *)arg1)->binaryJoinTree((gum::DAG const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::JunctionTree(static_cast< const gum::JunctionTree& >(result))), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::BayesNet< double > * >(argp2);
  arg3 = swig_obj[2];
  {
    try {
      result = ((JunctionTreeGenerator const *)arg1)->binaryJoinTree((gum::BayesNet< double > const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::JunctionTree(static_cast< const gum::JunctionTree& >(result))), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::JunctionTree result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "1"" of type '" "JunctionTreeGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionTreeGenerator_binaryJoinTree" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::BayesNet< double > * >(argp2);
  {
    try {
      result = ((JunctionTreeGenerator const *)arg1)->binaryJoinTree((gum::BayesNet< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::JunctionTree(static_cast< const gum::JunctionTree& >(result))), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionTreeGenerator_binaryJoinTree(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "JunctionTreeGenerator_binaryJoinTree", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_JunctionTreeGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_JunctionTreeGenerator_binaryJoinTree__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JunctionTreeGenerator_binaryJoinTree'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    JunctionTreeGenerator::binaryJoinTree(gum::UndiGraph const &,PyObject *) const\n"
    "    JunctionTreeGenerator::binaryJoinTree(gum::UndiGraph const &) const\n"
    "    JunctionTreeGenerator::binaryJoinTree(gum::DAG const &,PyObject *) const\n"
    "    JunctionTreeGenerator::binaryJoinTree(gum::DAG const &) const\n"
    "    JunctionTreeGenerator::binaryJoinTree(gum::BayesNet< double > const &,PyObject *) const\n"
    "    JunctionTreeGenerator::binaryJoinTree(gum::BayesNet< double > const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_JunctionTreeGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_JunctionTreeGenerator", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (JunctionTreeGenerator *)new JunctionTreeGenerator();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_JunctionTreeGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_JunctionTreeGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  JunctionTreeGenerator *arg1 = (JunctionTreeGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_JunctionTreeGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JunctionTreeGenerator" "', argument " "1"" of type '" "JunctionTreeGenerator *""'"); 
  }
  arg1 = reinterpret_cast< JunctionTreeGenerator * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *JunctionTreeGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_JunctionTreeGenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *JunctionTreeGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PythonBNListener(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::VariableNodeMap *arg2 = (gum::VariableNodeMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  PythonBNListener *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PythonBNListener", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PythonBNListener" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_gum__VariableNodeMap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PythonBNListener" "', argument " "2"" of type '" "gum::VariableNodeMap const *""'"); 
  }
  arg2 = reinterpret_cast< gum::VariableNodeMap * >(argp2);
  {
    try {
      result = (PythonBNListener *)new PythonBNListener((gum::BayesNet< double > const *)arg1,(gum::VariableNodeMap const *)arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PythonBNListener, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PythonBNListener(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = (PythonBNListener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonBNListener, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PythonBNListener" "', argument " "1"" of type '" "PythonBNListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonBNListener * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonBNListener_whenNodeAdded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = (PythonBNListener *) 0 ;
  void *arg2 = (void *) 0 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonBNListener_whenNodeAdded", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonBNListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonBNListener_whenNodeAdded" "', argument " "1"" of type '" "PythonBNListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonBNListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PythonBNListener_whenNodeAdded" "', argument " "2"" of type '" "void const *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PythonBNListener_whenNodeAdded" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->whenNodeAdded((void const *)arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonBNListener_whenNodeDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = (PythonBNListener *) 0 ;
  void *arg2 = (void *) 0 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonBNListener_whenNodeDeleted", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonBNListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonBNListener_whenNodeDeleted" "', argument " "1"" of type '" "PythonBNListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonBNListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PythonBNListener_whenNodeDeleted" "', argument " "2"" of type '" "void const *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PythonBNListener_whenNodeDeleted" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->whenNodeDeleted((void const *)arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonBNListener_whenArcAdded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = (PythonBNListener *) 0 ;
  void *arg2 = (void *) 0 ;
  gum::NodeId arg3 ;
  gum::NodeId arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonBNListener_whenArcAdded", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonBNListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonBNListener_whenArcAdded" "', argument " "1"" of type '" "PythonBNListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonBNListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PythonBNListener_whenArcAdded" "', argument " "2"" of type '" "void const *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PythonBNListener_whenArcAdded" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PythonBNListener_whenArcAdded" "', argument " "4"" of type '" "gum::NodeId""'");
  } 
  arg4 = static_cast< gum::NodeId >(val4);
  {
    try {
      (arg1)->whenArcAdded((void const *)arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonBNListener_whenArcDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = (PythonBNListener *) 0 ;
  void *arg2 = (void *) 0 ;
  gum::NodeId arg3 ;
  gum::NodeId arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonBNListener_whenArcDeleted", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonBNListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonBNListener_whenArcDeleted" "', argument " "1"" of type '" "PythonBNListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonBNListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PythonBNListener_whenArcDeleted" "', argument " "2"" of type '" "void const *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PythonBNListener_whenArcDeleted" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PythonBNListener_whenArcDeleted" "', argument " "4"" of type '" "gum::NodeId""'");
  } 
  arg4 = static_cast< gum::NodeId >(val4);
  {
    try {
      (arg1)->whenArcDeleted((void const *)arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonBNListener_setWhenArcAdded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = (PythonBNListener *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonBNListener_setWhenArcAdded", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonBNListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonBNListener_setWhenArcAdded" "', argument " "1"" of type '" "PythonBNListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonBNListener * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      (arg1)->setWhenArcAdded(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonBNListener_setWhenArcDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = (PythonBNListener *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonBNListener_setWhenArcDeleted", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonBNListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonBNListener_setWhenArcDeleted" "', argument " "1"" of type '" "PythonBNListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonBNListener * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      (arg1)->setWhenArcDeleted(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonBNListener_setWhenNodeAdded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = (PythonBNListener *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonBNListener_setWhenNodeAdded", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonBNListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonBNListener_setWhenNodeAdded" "', argument " "1"" of type '" "PythonBNListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonBNListener * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      (arg1)->setWhenNodeAdded(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonBNListener_setWhenNodeDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonBNListener *arg1 = (PythonBNListener *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonBNListener_setWhenNodeDeleted", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonBNListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonBNListener_setWhenNodeDeleted" "', argument " "1"" of type '" "PythonBNListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonBNListener * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      (arg1)->setWhenNodeDeleted(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PythonBNListener_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_PythonBNListener, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PythonBNListener_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_PythonLoadListener_whenLoading(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonLoadListener *arg1 = (PythonLoadListener *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonLoadListener_whenLoading", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonLoadListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonLoadListener_whenLoading" "', argument " "1"" of type '" "PythonLoadListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonLoadListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PythonLoadListener_whenLoading" "', argument " "2"" of type '" "void const *""'"); 
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PythonLoadListener_whenLoading" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      (arg1)->whenLoading((void const *)arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonLoadListener_setPythonListener(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonLoadListener *arg1 = (PythonLoadListener *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonLoadListener_setPythonListener", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonLoadListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonLoadListener_setPythonListener" "', argument " "1"" of type '" "PythonLoadListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonLoadListener * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (bool)(arg1)->setPythonListener(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PythonLoadListener(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonLoadListener *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PythonLoadListener", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (PythonLoadListener *)new PythonLoadListener();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PythonLoadListener, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PythonLoadListener(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonLoadListener *arg1 = (PythonLoadListener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonLoadListener, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PythonLoadListener" "', argument " "1"" of type '" "PythonLoadListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonLoadListener * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PythonLoadListener_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_PythonLoadListener, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PythonLoadListener_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap___fillLoadListeners(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< PythonLoadListener,std::allocator< PythonLoadListener > > *arg1 = 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "__fillLoadListeners", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_PythonLoadListener_std__allocatorT_PythonLoadListener_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__fillLoadListeners" "', argument " "1"" of type '" "std::vector< PythonLoadListener,std::allocator< PythonLoadListener > > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__fillLoadListeners" "', argument " "1"" of type '" "std::vector< PythonLoadListener,std::allocator< PythonLoadListener > > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< PythonLoadListener,std::allocator< PythonLoadListener > > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (int)__fillLoadListeners(*arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PythonApproximationListener(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IApproximationSchemeConfiguration *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PythonApproximationListener *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__IApproximationSchemeConfiguration,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PythonApproximationListener" "', argument " "1"" of type '" "gum::IApproximationSchemeConfiguration &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PythonApproximationListener" "', argument " "1"" of type '" "gum::IApproximationSchemeConfiguration &""'"); 
  }
  arg1 = reinterpret_cast< gum::IApproximationSchemeConfiguration * >(argp1);
  {
    try {
      result = (PythonApproximationListener *)new PythonApproximationListener(*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PythonApproximationListener, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PythonApproximationListener(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonApproximationListener *arg1 = (PythonApproximationListener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonApproximationListener, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PythonApproximationListener" "', argument " "1"" of type '" "PythonApproximationListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonApproximationListener * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonApproximationListener_whenProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonApproximationListener *arg1 = (PythonApproximationListener *) 0 ;
  void *arg2 = (void *) 0 ;
  gum::Size arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonApproximationListener_whenProgress", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonApproximationListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonApproximationListener_whenProgress" "', argument " "1"" of type '" "PythonApproximationListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonApproximationListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PythonApproximationListener_whenProgress" "', argument " "2"" of type '" "void const *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PythonApproximationListener_whenProgress" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PythonApproximationListener_whenProgress" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PythonApproximationListener_whenProgress" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    try {
      (arg1)->whenProgress((void const *)arg2,arg3,arg4,arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonApproximationListener_whenStop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonApproximationListener *arg1 = (PythonApproximationListener *) 0 ;
  void *arg2 = (void *) 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonApproximationListener_whenStop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonApproximationListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonApproximationListener_whenStop" "', argument " "1"" of type '" "PythonApproximationListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonApproximationListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PythonApproximationListener_whenStop" "', argument " "2"" of type '" "void const *""'"); 
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PythonApproximationListener_whenStop" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      (arg1)->whenStop((void const *)arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonApproximationListener_setWhenProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonApproximationListener *arg1 = (PythonApproximationListener *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonApproximationListener_setWhenProgress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonApproximationListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonApproximationListener_setWhenProgress" "', argument " "1"" of type '" "PythonApproximationListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonApproximationListener * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      (arg1)->setWhenProgress(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonApproximationListener_setWhenStop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonApproximationListener *arg1 = (PythonApproximationListener *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonApproximationListener_setWhenStop", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonApproximationListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonApproximationListener_setWhenStop" "', argument " "1"" of type '" "PythonApproximationListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonApproximationListener * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      (arg1)->setWhenStop(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PythonApproximationListener_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_PythonApproximationListener, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PythonApproximationListener_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PythonDatabaseGeneratorListener(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PythonDatabaseGeneratorListener *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PythonDatabaseGeneratorListener" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PythonDatabaseGeneratorListener" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > &""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    try {
      result = (PythonDatabaseGeneratorListener *)new PythonDatabaseGeneratorListener(*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PythonDatabaseGeneratorListener, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PythonDatabaseGeneratorListener(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonDatabaseGeneratorListener *arg1 = (PythonDatabaseGeneratorListener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonDatabaseGeneratorListener, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PythonDatabaseGeneratorListener" "', argument " "1"" of type '" "PythonDatabaseGeneratorListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonDatabaseGeneratorListener * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonDatabaseGeneratorListener_whenProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonDatabaseGeneratorListener *arg1 = (PythonDatabaseGeneratorListener *) 0 ;
  void *arg2 = (void *) 0 ;
  gum::Size arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonDatabaseGeneratorListener_whenProgress", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonDatabaseGeneratorListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonDatabaseGeneratorListener_whenProgress" "', argument " "1"" of type '" "PythonDatabaseGeneratorListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonDatabaseGeneratorListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PythonDatabaseGeneratorListener_whenProgress" "', argument " "2"" of type '" "void const *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PythonDatabaseGeneratorListener_whenProgress" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PythonDatabaseGeneratorListener_whenProgress" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    try {
      (arg1)->whenProgress((void const *)arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonDatabaseGeneratorListener_whenStop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonDatabaseGeneratorListener *arg1 = (PythonDatabaseGeneratorListener *) 0 ;
  void *arg2 = (void *) 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonDatabaseGeneratorListener_whenStop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonDatabaseGeneratorListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonDatabaseGeneratorListener_whenStop" "', argument " "1"" of type '" "PythonDatabaseGeneratorListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonDatabaseGeneratorListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PythonDatabaseGeneratorListener_whenStop" "', argument " "2"" of type '" "void const *""'"); 
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PythonDatabaseGeneratorListener_whenStop" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PythonDatabaseGeneratorListener_whenStop" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->whenStop((void const *)arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonDatabaseGeneratorListener_setWhenProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonDatabaseGeneratorListener *arg1 = (PythonDatabaseGeneratorListener *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonDatabaseGeneratorListener_setWhenProgress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonDatabaseGeneratorListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonDatabaseGeneratorListener_setWhenProgress" "', argument " "1"" of type '" "PythonDatabaseGeneratorListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonDatabaseGeneratorListener * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      (arg1)->setWhenProgress(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PythonDatabaseGeneratorListener_setWhenStop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PythonDatabaseGeneratorListener *arg1 = (PythonDatabaseGeneratorListener *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PythonDatabaseGeneratorListener_setWhenStop", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PythonDatabaseGeneratorListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PythonDatabaseGeneratorListener_setWhenStop" "', argument " "1"" of type '" "PythonDatabaseGeneratorListener *""'"); 
  }
  arg1 = reinterpret_cast< PythonDatabaseGeneratorListener * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      (arg1)->setWhenStop(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PythonDatabaseGeneratorListener_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_PythonDatabaseGeneratorListener, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PythonDatabaseGeneratorListener_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_BNGenerator_generate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BNGenerator *arg1 = (BNGenerator *) 0 ;
  gum::Size arg2 ;
  gum::Size arg3 ;
  gum::Size arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  gum::BayesNet< double > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BNGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNGenerator_generate" "', argument " "1"" of type '" "BNGenerator *""'"); 
  }
  arg1 = reinterpret_cast< BNGenerator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNGenerator_generate" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNGenerator_generate" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BNGenerator_generate" "', argument " "4"" of type '" "gum::Size""'");
  } 
  arg4 = static_cast< gum::Size >(val4);
  {
    try {
      result = (arg1)->generate(arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(static_cast< const gum::BayesNet< double >& >(result))), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNGenerator_generate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BNGenerator *arg1 = (BNGenerator *) 0 ;
  gum::Size arg2 ;
  gum::Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::BayesNet< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BNGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNGenerator_generate" "', argument " "1"" of type '" "BNGenerator *""'"); 
  }
  arg1 = reinterpret_cast< BNGenerator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNGenerator_generate" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNGenerator_generate" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  {
    try {
      result = (arg1)->generate(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(static_cast< const gum::BayesNet< double >& >(result))), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNGenerator_generate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BNGenerator *arg1 = (BNGenerator *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::BayesNet< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BNGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNGenerator_generate" "', argument " "1"" of type '" "BNGenerator *""'"); 
  }
  arg1 = reinterpret_cast< BNGenerator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNGenerator_generate" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = (arg1)->generate(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(static_cast< const gum::BayesNet< double >& >(result))), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNGenerator_generate__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BNGenerator *arg1 = (BNGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::BayesNet< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BNGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNGenerator_generate" "', argument " "1"" of type '" "BNGenerator *""'"); 
  }
  arg1 = reinterpret_cast< BNGenerator * >(argp1);
  {
    try {
      result = (arg1)->generate();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(static_cast< const gum::BayesNet< double >& >(result))), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNGenerator_generate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNGenerator_generate", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BNGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BNGenerator_generate__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BNGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BNGenerator_generate__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BNGenerator, 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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BNGenerator_generate__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BNGenerator, 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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BNGenerator_generate__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNGenerator_generate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BNGenerator::generate(gum::Size,gum::Size,gum::Size)\n"
    "    BNGenerator::generate(gum::Size,gum::Size)\n"
    "    BNGenerator::generate(gum::Size)\n"
    "    BNGenerator::generate()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_BNGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  BNGenerator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BNGenerator", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (BNGenerator *)new BNGenerator();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BNGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BNGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  BNGenerator *arg1 = (BNGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BNGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BNGenerator" "', argument " "1"" of type '" "BNGenerator *""'"); 
  }
  arg1 = reinterpret_cast< BNGenerator * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BNGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_BNGenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BNGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_IDGenerator_generate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IDGenerator *arg1 = (IDGenerator *) 0 ;
  gum::Size arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  gum::InfluenceDiagram< double > result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IDGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IDGenerator_generate" "', argument " "1"" of type '" "IDGenerator *""'"); 
  }
  arg1 = reinterpret_cast< IDGenerator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IDGenerator_generate" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IDGenerator_generate" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IDGenerator_generate" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IDGenerator_generate" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IDGenerator_generate" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  {
    try {
      result = (arg1)->generate(arg2,arg3,arg4,arg5,arg6);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::InfluenceDiagram< double >(static_cast< const gum::InfluenceDiagram< double >& >(result))), SWIGTYPE_p_gum__InfluenceDiagramT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IDGenerator_generate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IDGenerator *arg1 = (IDGenerator *) 0 ;
  gum::Size arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  gum::InfluenceDiagram< double > result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IDGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IDGenerator_generate" "', argument " "1"" of type '" "IDGenerator *""'"); 
  }
  arg1 = reinterpret_cast< IDGenerator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IDGenerator_generate" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IDGenerator_generate" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IDGenerator_generate" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IDGenerator_generate" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    try {
      result = (arg1)->generate(arg2,arg3,arg4,arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::InfluenceDiagram< double >(static_cast< const gum::InfluenceDiagram< double >& >(result))), SWIGTYPE_p_gum__InfluenceDiagramT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IDGenerator_generate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IDGenerator *arg1 = (IDGenerator *) 0 ;
  gum::Size arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  gum::InfluenceDiagram< double > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IDGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IDGenerator_generate" "', argument " "1"" of type '" "IDGenerator *""'"); 
  }
  arg1 = reinterpret_cast< IDGenerator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IDGenerator_generate" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IDGenerator_generate" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IDGenerator_generate" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    try {
      result = (arg1)->generate(arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::InfluenceDiagram< double >(static_cast< const gum::InfluenceDiagram< double >& >(result))), SWIGTYPE_p_gum__InfluenceDiagramT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IDGenerator_generate__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IDGenerator *arg1 = (IDGenerator *) 0 ;
  gum::Size arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  gum::InfluenceDiagram< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IDGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IDGenerator_generate" "', argument " "1"" of type '" "IDGenerator *""'"); 
  }
  arg1 = reinterpret_cast< IDGenerator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IDGenerator_generate" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IDGenerator_generate" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (arg1)->generate(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::InfluenceDiagram< double >(static_cast< const gum::InfluenceDiagram< double >& >(result))), SWIGTYPE_p_gum__InfluenceDiagramT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IDGenerator_generate__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IDGenerator *arg1 = (IDGenerator *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::InfluenceDiagram< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IDGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IDGenerator_generate" "', argument " "1"" of type '" "IDGenerator *""'"); 
  }
  arg1 = reinterpret_cast< IDGenerator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IDGenerator_generate" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = (arg1)->generate(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::InfluenceDiagram< double >(static_cast< const gum::InfluenceDiagram< double >& >(result))), SWIGTYPE_p_gum__InfluenceDiagramT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IDGenerator_generate__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IDGenerator *arg1 = (IDGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::InfluenceDiagram< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IDGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IDGenerator_generate" "', argument " "1"" of type '" "IDGenerator *""'"); 
  }
  arg1 = reinterpret_cast< IDGenerator * >(argp1);
  {
    try {
      result = (arg1)->generate();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::InfluenceDiagram< double >(static_cast< const gum::InfluenceDiagram< double >& >(result))), SWIGTYPE_p_gum__InfluenceDiagramT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IDGenerator_generate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IDGenerator_generate", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_IDGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_IDGenerator_generate__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_IDGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IDGenerator_generate__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_IDGenerator, 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_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_IDGenerator_generate__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_IDGenerator, 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_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_IDGenerator_generate__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_IDGenerator, 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_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_IDGenerator_generate__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_IDGenerator, 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_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_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_IDGenerator_generate__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IDGenerator_generate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    IDGenerator::generate(gum::Size,double,double,double,int)\n"
    "    IDGenerator::generate(gum::Size,double,double,double)\n"
    "    IDGenerator::generate(gum::Size,double,double)\n"
    "    IDGenerator::generate(gum::Size,double)\n"
    "    IDGenerator::generate(gum::Size)\n"
    "    IDGenerator::generate()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_IDGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IDGenerator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_IDGenerator", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (IDGenerator *)new IDGenerator();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IDGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IDGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IDGenerator *arg1 = (IDGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IDGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IDGenerator" "', argument " "1"" of type '" "IDGenerator *""'"); 
  }
  arg1 = reinterpret_cast< IDGenerator * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IDGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_IDGenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IDGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PRMexplorer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PRMexplorer", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (PRMexplorer *)new PRMexplorer();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PRMexplorer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PRMexplorer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PRMexplorer" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_load" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_load" "', 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(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_load" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PRMexplorer_load" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      (arg1)->load(arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_load" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_load" "', 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(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_load" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      (arg1)->load(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_load__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_load" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_load" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      (arg1)->load(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_load(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PRMexplorer_load", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_PRMexplorer, 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_PRMexplorer_load__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_PRMexplorer, 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_PRMexplorer_load__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_PRMexplorer, 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_PRMexplorer_load__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PRMexplorer_load'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PRMexplorer::load(std::string,std::string,bool)\n"
    "    PRMexplorer::load(std::string,std::string)\n"
    "    PRMexplorer::load(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_isType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_isType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_isType" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_isType" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->isType(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_isClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_isClass", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_isClass" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_isClass" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->isClass(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_isInterface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_isInterface", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_isInterface" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_isInterface" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->isInterface(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_classes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_classes" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    try {
      result = (PyObject *)(arg1)->classes();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_classAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_classAttributes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_classAttributes" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_classAttributes" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->classAttributes(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_isAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_isAttribute", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_isAttribute" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_isAttribute" "', 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(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_isAttribute" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->isAttribute(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_classReferences(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_classReferences", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_classReferences" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_classReferences" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->classReferences(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_classParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_classParameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_classParameters" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_classParameters" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->classParameters(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_classImplements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_classImplements", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_classImplements" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_classImplements" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->classImplements(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_aggType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_aggType_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_aggType_set" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__string, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PRMexplorer_aggType_set" "', argument " "2"" of type '" "std::string [9]""'"); 
  } 
  arg2 = reinterpret_cast< std::string * >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)9; ++ii) *(std::string *)&arg1->aggType[ii] = *((std::string *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""aggType""' of type '""std::string [9]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_aggType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_aggType_get" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  result = (std::string *)(std::string *) ((arg1)->aggType);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_classAggregates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_classAggregates", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_classAggregates" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_classAggregates" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->classAggregates(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_classSlotChains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_classSlotChains", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_classSlotChains" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_classSlotChains" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->classSlotChains(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_classDag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_classDag", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_classDag" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_classDag" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->classDag(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getalltheSystems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_getalltheSystems" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    try {
      result = (PyObject *)(arg1)->getalltheSystems();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getSuperClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_getSuperClass", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_getSuperClass" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_getSuperClass" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->getSuperClass(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getDirectSubClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_getDirectSubClass", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_getDirectSubClass" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_getDirectSubClass" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->getDirectSubClass(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_cpf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  gum::Potential< double > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_cpf", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_cpf" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_cpf" "', 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(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_cpf" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::Potential< double > *) &(arg1)->cpf(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_types(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_types" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    try {
      result = (PyObject *)(arg1)->types();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getSuperType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_getSuperType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_getSuperType" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_getSuperType" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->getSuperType(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getDirectSubTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_getDirectSubTypes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_getDirectSubTypes" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_getDirectSubTypes" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->getDirectSubTypes(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getLabels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_getLabels", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_getLabels" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_getLabels" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->getLabels(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getLabelMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_getLabelMap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_getLabelMap" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_getLabelMap" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->getLabelMap(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_interfaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_interfaces" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    try {
      result = (PyObject *)(arg1)->interfaces();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_interAttributes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_interAttributes" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_interAttributes" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PRMexplorer_interAttributes" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (PyObject *)(arg1)->interAttributes(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_interAttributes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_interAttributes" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_interAttributes" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->interAttributes(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_interAttributes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PRMexplorer_interAttributes", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_PRMexplorer, 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_PRMexplorer_interAttributes__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_PRMexplorer, 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_PRMexplorer_interAttributes__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PRMexplorer_interAttributes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PRMexplorer::interAttributes(std::string,bool)\n"
    "    PRMexplorer::interAttributes(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_interReferences(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_interReferences", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_interReferences" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_interReferences" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->interReferences(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getSuperInterface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_getSuperInterface", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_getSuperInterface" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_getSuperInterface" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->getSuperInterface(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getDirectSubInterfaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_getDirectSubInterfaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_getDirectSubInterfaces" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_getDirectSubInterfaces" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->getDirectSubInterfaces(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PRMexplorer_getImplementations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PRMexplorer *arg1 = (PRMexplorer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PRMexplorer_getImplementations", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PRMexplorer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PRMexplorer_getImplementations" "', argument " "1"" of type '" "PRMexplorer *""'"); 
  }
  arg1 = reinterpret_cast< PRMexplorer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PRMexplorer_getImplementations" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (PyObject *)(arg1)->getImplementations(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PRMexplorer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_PRMexplorer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PRMexplorer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Vector_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_iterator" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      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_Vector___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector___nonzero__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector___bool__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_double_Sg____bool__((std::vector< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector___len__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = std_vector_Sl_double_Sg____len__((std::vector< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector___getslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector___getslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector___getslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_double_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  std::vector< double,std::allocator< double > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Vector___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_double_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > 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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(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_Vector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(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< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Vector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type)\n"
    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector___delslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector___delslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector___delslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_double_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector___delitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_double_Sg____delitem____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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector___getitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vector___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_double_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< double,std::allocator< double > > 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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_double_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_double_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Vector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::__delitem__(std::vector< double >::difference_type)\n"
    "    std::vector< double >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector___getitem__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector___getitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg____getitem____SWIG_1((std::vector< double > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Vector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::__getitem__(PySliceObject *)\n"
    "    std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector___setitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector___setitem__" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      try {
        std_vector_Sl_double_Sg____setitem____SWIG_2(arg1,arg2,(double const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Vector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Vector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(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_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Vector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
    "    std::vector< double >::__setitem__(PySliceObject *)\n"
    "    std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_pop" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      try {
        result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_append" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_append" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
  } 
  temp2 = static_cast< std::vector< double >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      std_vector_Sl_double_Sg__append(arg1,(double const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< double > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< double > *)new std::vector< double >();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "std::vector< double > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Vector" "', argument " "1"" of type '" "std::vector< double > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_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_Vector_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_empty" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (bool)((std::vector< double > const *)arg1)->empty();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_size" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = ((std::vector< double > const *)arg1)->size();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_swap" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_swap" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_swap" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_begin" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_end" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_rbegin" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_rend" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_clear" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = ((std::vector< double > const *)arg1)->get_allocator();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vector" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
  } 
  arg1 = static_cast< std::vector< double >::size_type >(val1);
  {
    try {
      result = (std::vector< double > *)new std::vector< double >(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_pop_back" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_resize" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< double >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_erase" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_double_Sg__erase__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  std::vector< double >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< double >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_erase" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_double_Sg__erase__SWIG_1(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(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<std::vector< double >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_Vector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(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<std::vector< double >::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<std::vector< double >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_Vector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::erase(std::vector< double >::iterator)\n"
    "    std::vector< double >::erase(std::vector< double >::iterator,std::vector< double >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Vector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double >::size_type arg1 ;
  std::vector< double >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< double >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  std::vector< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vector" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
  } 
  arg1 = static_cast< std::vector< double >::size_type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
  } 
  temp2 = static_cast< std::vector< double >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = (std::vector< double > *)new std::vector< double >(arg1,(std::vector< double >::value_type const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Vector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Vector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Vector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_new_Vector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Vector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::vector()\n"
    "    std::vector< double >::vector(std::vector< double > const &)\n"
    "    std::vector< double >::vector(std::vector< double >::size_type)\n"
    "    std::vector< double >::vector(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_push_back" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_push_back" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
  } 
  temp2 = static_cast< std::vector< double >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_front" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->front();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_back" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->back();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_assign" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_assign" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_assign" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->assign(arg2,(std::vector< double >::value_type const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_resize" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_resize" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->resize(arg2,(std::vector< double >::value_type const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(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_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Vector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::resize(std::vector< double >::size_type)\n"
    "    std::vector< double >::resize(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  std::vector< double >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_insert" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_insert" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      result = std_vector_Sl_double_Sg__insert__SWIG_0(arg1,arg2,(double const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  std::vector< double >::size_type arg3 ;
  std::vector< double >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::vector< double >::value_type temp4 ;
  double val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_insert" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_insert" "', argument " "3"" of type '" "std::vector< double >::size_type""'");
  } 
  arg3 = static_cast< std::vector< double >::size_type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Vector_insert" "', argument " "4"" of type '" "std::vector< double >::value_type""'");
  } 
  temp4 = static_cast< std::vector< double >::value_type >(val4);
  arg4 = &temp4;
  {
    try {
      std_vector_Sl_double_Sg__insert__SWIG_1(arg1,arg2,arg3,(double const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(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<std::vector< double >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Vector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(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<std::vector< double >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(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_Vector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::value_type const &)\n"
    "    std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_reserve" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_reserve" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_capacity" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = ((std::vector< double > const *)arg1)->capacity();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vector" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Vector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Vector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Vector_int_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_iterator" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_unsigned_SS_int_Sg__iterator(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      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_Vector_int___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___nonzero__" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_unsigned_SS_int_Sg____nonzero__((std::vector< unsigned int > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___bool__" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_unsigned_SS_int_Sg____bool__((std::vector< unsigned int > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___len__" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = std_vector_Sl_unsigned_SS_int_Sg____len__((std::vector< unsigned int > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_int___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___getslice__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_int___getslice__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_int___getslice__" "', argument " "3"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< unsigned int >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< unsigned int,std::allocator< unsigned int > > *)std_vector_Sl_unsigned_SS_int_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___setslice__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_int___setslice__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_int___setslice__" "', argument " "3"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< unsigned int >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___setslice__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_int___setslice__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_int___setslice__" "', argument " "3"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< unsigned int >::difference_type >(val3);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Vector_int___setslice__" "', argument " "4"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_int___setslice__" "', argument " "4"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< unsigned int,std::allocator< unsigned int > > 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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_int___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(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_Vector_int___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(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< unsigned int,std::allocator< unsigned int > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Vector_int___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_int___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::__setslice__(std::vector< unsigned int >::difference_type,std::vector< unsigned int >::difference_type)\n"
    "    std::vector< unsigned int >::__setslice__(std::vector< unsigned int >::difference_type,std::vector< unsigned int >::difference_type,std::vector< unsigned int,std::allocator< unsigned int > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_int___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_int___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___delslice__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_int___delslice__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_int___delslice__" "', argument " "3"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< unsigned int >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___delitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_int___delitem__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____delitem____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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___getitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< unsigned int,std::allocator< unsigned int > > *)std_vector_Sl_unsigned_SS_int_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___setitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vector_int___setitem__" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_int___setitem__" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< unsigned int,std::allocator< unsigned int > > 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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___setitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___delitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_int___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Vector_int___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector_int___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_int___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::__delitem__(std::vector< unsigned int >::difference_type)\n"
    "    std::vector< unsigned int >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_int___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___getitem__" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_int___getitem__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< unsigned int >::value_type *) &std_vector_Sl_unsigned_SS_int_Sg____getitem____SWIG_1((std::vector< unsigned int > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_int___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Vector_int___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector_int___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_int___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::__getitem__(PySliceObject *)\n"
    "    std::vector< unsigned int >::__getitem__(std::vector< unsigned int >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_int___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int >::value_type temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int___setitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_int___setitem__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_int___setitem__" "', argument " "3"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< unsigned int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_2(arg1,arg2,(unsigned int const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_int___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Vector_int___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Vector_int___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(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_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Vector_int___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_int___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::__setitem__(PySliceObject *,std::vector< unsigned int,std::allocator< unsigned int > > const &)\n"
    "    std::vector< unsigned int >::__setitem__(PySliceObject *)\n"
    "    std::vector< unsigned int >::__setitem__(std::vector< unsigned int >::difference_type,std::vector< unsigned int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_int_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_pop" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      try {
        result = (std::vector< unsigned int >::value_type)std_vector_Sl_unsigned_SS_int_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int >::value_type temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_int_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_append" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_int_append" "', argument " "2"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< unsigned int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      std_vector_Sl_unsigned_SS_int_Sg__append(arg1,(unsigned int const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector_int__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector_int__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< unsigned int > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector_int" "', argument " "1"" of type '" "std::vector< unsigned int > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Vector_int" "', argument " "1"" of type '" "std::vector< unsigned int > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_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_Vector_int_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_empty" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (bool)((std::vector< unsigned int > const *)arg1)->empty();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_size" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = ((std::vector< unsigned int > const *)arg1)->size();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_int_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_swap" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_int_swap" "', argument " "2"" of type '" "std::vector< unsigned int > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_int_swap" "', argument " "2"" of type '" "std::vector< unsigned int > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< unsigned int > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_begin" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_end" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_rbegin" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_rend" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_clear" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_get_allocator" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = ((std::vector< unsigned int > const *)arg1)->get_allocator();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< unsigned int >::allocator_type(static_cast< const std::vector< unsigned int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_unsigned_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector_int__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< unsigned int > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vector_int" "', argument " "1"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg1 = static_cast< std::vector< unsigned int >::size_type >(val1);
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_pop_back" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_resize" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_int_resize" "', argument " "2"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< unsigned int >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_erase" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int_erase" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int_erase" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_unsigned_SS_int_Sg__erase__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::iterator arg2 ;
  std::vector< unsigned int >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< unsigned int >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_erase" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int_erase" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int_erase" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int_erase" "', argument " "3"" of type '" "std::vector< unsigned int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int_erase" "', argument " "3"" of type '" "std::vector< unsigned int >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_unsigned_SS_int_Sg__erase__SWIG_1(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_int_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(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<std::vector< unsigned int >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_Vector_int_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(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<std::vector< unsigned int >::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<std::vector< unsigned int >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_Vector_int_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_int_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::erase(std::vector< unsigned int >::iterator)\n"
    "    std::vector< unsigned int >::erase(std::vector< unsigned int >::iterator,std::vector< unsigned int >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Vector_int__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int >::size_type arg1 ;
  std::vector< unsigned int >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< unsigned int >::value_type temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vector_int" "', argument " "1"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg1 = static_cast< std::vector< unsigned int >::size_type >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector_int" "', argument " "2"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< unsigned int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >(arg1,(std::vector< unsigned int >::value_type const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector_int(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Vector_int", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Vector_int__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Vector_int__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector_int__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Vector_int__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Vector_int'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::vector()\n"
    "    std::vector< unsigned int >::vector(std::vector< unsigned int > const &)\n"
    "    std::vector< unsigned int >::vector(std::vector< unsigned int >::size_type)\n"
    "    std::vector< unsigned int >::vector(std::vector< unsigned int >::size_type,std::vector< unsigned int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_int_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int >::value_type temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_int_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_push_back" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_int_push_back" "', argument " "2"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< unsigned int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      (arg1)->push_back((std::vector< unsigned int >::value_type const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_front" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (std::vector< unsigned int >::value_type *) &((std::vector< unsigned int > const *)arg1)->front();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_back" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (std::vector< unsigned int >::value_type *) &((std::vector< unsigned int > const *)arg1)->back();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  std::vector< unsigned int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int >::value_type temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_int_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_assign" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_int_assign" "', argument " "2"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::size_type >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_int_assign" "', argument " "3"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< unsigned int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->assign(arg2,(std::vector< unsigned int >::value_type const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  std::vector< unsigned int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int >::value_type temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_resize" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_int_resize" "', argument " "2"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::size_type >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_int_resize" "', argument " "3"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< unsigned int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->resize(arg2,(std::vector< unsigned int >::value_type const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_int_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector_int_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(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_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Vector_int_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_int_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::resize(std::vector< unsigned int >::size_type)\n"
    "    std::vector< unsigned int >::resize(std::vector< unsigned int >::size_type,std::vector< unsigned int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_int_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::iterator arg2 ;
  std::vector< unsigned int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< unsigned int >::value_type temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  std::vector< unsigned int >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_insert" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int_insert" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int_insert" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_int_insert" "', argument " "3"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< unsigned int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      result = std_vector_Sl_unsigned_SS_int_Sg__insert__SWIG_0(arg1,arg2,(unsigned int const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::iterator arg2 ;
  std::vector< unsigned int >::size_type arg3 ;
  std::vector< unsigned int >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::vector< unsigned int >::value_type temp4 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_insert" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int_insert" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_int_insert" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_int_insert" "', argument " "3"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg3 = static_cast< std::vector< unsigned int >::size_type >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Vector_int_insert" "', argument " "4"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp4 = static_cast< std::vector< unsigned int >::value_type >(val4);
  arg4 = &temp4;
  {
    try {
      std_vector_Sl_unsigned_SS_int_Sg__insert__SWIG_1(arg1,arg2,arg3,(unsigned int const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_int_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(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<std::vector< unsigned int >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Vector_int_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(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<std::vector< unsigned int >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Vector_int_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_int_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::insert(std::vector< unsigned int >::iterator,std::vector< unsigned int >::value_type const &)\n"
    "    std::vector< unsigned int >::insert(std::vector< unsigned int >::iterator,std::vector< unsigned int >::size_type,std::vector< unsigned int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_int_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_int_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_reserve" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_int_reserve" "', argument " "2"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_int_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_int_capacity" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = ((std::vector< unsigned int > const *)arg1)->capacity();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Vector_int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vector_int" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Vector_int_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Vector_int_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Vector_string_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_iterator" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_string_Sg__iterator(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      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_Vector_string___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string___nonzero__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_string_Sg____nonzero__((std::vector< std::string > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string___bool__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_string_Sg____bool__((std::vector< std::string > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string___len__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_string_Sg____len__((std::vector< std::string > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_string___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string___getslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_string___getslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_string___getslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_string___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_string___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_string_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_string___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_string___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Vector_string___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_string___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::string,std::allocator< std::string > > 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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_string___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(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_Vector_string___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(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< std::string,std::allocator< std::string > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Vector_string___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_string___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type)\n"
    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_string___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_string___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string___delslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_string___delslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_string___delslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_string_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string___delitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_string___delitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____delitem____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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string___getitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_string___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_string___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vector_string___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_string___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::string,std::allocator< std::string > > 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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_string___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_string_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string___delitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_string___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_string_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());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_string___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Vector_string___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector_string___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_string___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__delitem__(std::vector< std::string >::difference_type)\n"
    "    std::vector< std::string >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_string___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::string >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string___getitem__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_string___getitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg____getitem____SWIG_1((std::vector< std::string > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_string___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Vector_string___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector_string___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_string___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__getitem__(PySliceObject *)\n"
    "    std::vector< std::string >::__getitem__(std::vector< std::string >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_string___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_string___setitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vector_string___setitem__" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_string___setitem__" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____setitem____SWIG_2(arg1,arg2,(std::string const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_string___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Vector_string___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Vector_string___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Vector_string___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_string___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__setitem__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    std::vector< std::string >::__setitem__(PySliceObject *)\n"
    "    std::vector< std::string >::__setitem__(std::vector< std::string >::difference_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_string_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_pop" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_string_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_string_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_append" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_string_append" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_string_append" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_std_string_Sg__append(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector_string__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector_string__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::string > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector_string" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Vector_string" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_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_Vector_string_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_empty" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::string > const *)arg1)->empty();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_size" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = ((std::vector< std::string > const *)arg1)->size();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_string_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_swap" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &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 '" "Vector_string_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_string_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_begin" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_end" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_rbegin" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_rend" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_clear" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_get_allocator" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = ((std::vector< std::string > const *)arg1)->get_allocator();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::string >::allocator_type(static_cast< const std::vector< std::string >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__string_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector_string__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vector_string" "', argument " "1"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::string >::size_type >(val1);
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_pop_back" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_resize" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_string_resize" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::string >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_erase" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_string_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_string_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_string_Sg__erase__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::string >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_erase" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_string_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_string_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_string_erase" "', argument " "3"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_string_erase" "', argument " "3"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_string_Sg__erase__SWIG_1(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_string_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(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<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_Vector_string_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(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<std::vector< std::string >::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<std::vector< std::string >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_Vector_string_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_string_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::erase(std::vector< std::string >::iterator)\n"
    "    std::vector< std::string >::erase(std::vector< std::string >::iterator,std::vector< std::string >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Vector_string__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string >::size_type arg1 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::string > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vector_string" "', argument " "1"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::string >::size_type >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Vector_string" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Vector_string" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >(arg1,(std::vector< std::string >::value_type const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vector_string(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Vector_string", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Vector_string__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Vector_string__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector_string__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_new_Vector_string__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Vector_string'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::vector()\n"
    "    std::vector< std::string >::vector(std::vector< std::string > const &)\n"
    "    std::vector< std::string >::vector(std::vector< std::string >::size_type)\n"
    "    std::vector< std::string >::vector(std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_string_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_string_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_push_back" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_string_push_back" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_string_push_back" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_front" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->front();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_back" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->back();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_string_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_assign" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_string_assign" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vector_string_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_string_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< std::string >::value_type const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_resize" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_string_resize" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vector_string_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_string_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< std::string >::value_type const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_string_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector_string_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Vector_string_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_string_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::resize(std::vector< std::string >::size_type)\n"
    "    std::vector< std::string >::resize(std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_string_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::string >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_insert" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_string_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_string_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vector_string_insert" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_string_insert" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_std_string_Sg__insert__SWIG_0(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::size_type arg3 ;
  std::vector< std::string >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_insert" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_string_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Vector_string_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_string_insert" "', argument " "3"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::size_type >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Vector_string_insert" "', argument " "4"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_string_insert" "', argument " "4"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_std_string_Sg__insert__SWIG_1(arg1,arg2,arg3,(std::string const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_string_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(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<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Vector_string_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(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<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(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_Vector_string_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_string_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::insert(std::vector< std::string >::iterator,std::vector< std::string >::value_type const &)\n"
    "    std::vector< std::string >::insert(std::vector< std::string >::iterator,std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vector_string_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Vector_string_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_reserve" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_string_reserve" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vector_string_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &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 '" "Vector_string_capacity" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = ((std::vector< std::string > const *)arg1)->capacity();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Vector_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vector_string" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Vector_string_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Vector_string_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SetIteratorStaticEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::SetIteratorStaticEnd *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SetIteratorStaticEnd", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (gum::SetIteratorStaticEnd *)new gum::SetIteratorStaticEnd();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SetIteratorStaticEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SetIteratorStaticEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::SetIteratorStaticEnd *arg1 = (gum::SetIteratorStaticEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__SetIteratorStaticEnd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SetIteratorStaticEnd" "', argument " "1"" of type '" "gum::SetIteratorStaticEnd *""'"); 
  }
  arg1 = reinterpret_cast< gum::SetIteratorStaticEnd * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SetIteratorStaticEnd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__SetIteratorStaticEnd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SetIteratorStaticEnd_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GumException__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::Exception *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_GumException" "', 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(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_GumException" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::Exception *)new gum::Exception(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Exception, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GumException__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::Exception *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_GumException" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::Exception *)new gum::Exception(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Exception, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GumException__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::Exception *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (gum::Exception *)new gum::Exception();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Exception, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GumException__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Exception *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Exception *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__Exception,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GumException" "', argument " "1"" of type '" "gum::Exception const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GumException" "', argument " "1"" of type '" "gum::Exception const &""'"); 
  }
  arg1 = reinterpret_cast< gum::Exception * >(argp1);
  {
    try {
      result = (gum::Exception *)new gum::Exception((gum::Exception const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Exception, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GumException(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GumException", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GumException__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__Exception, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GumException__SWIG_3(self, argc, argv);
    }
  }
  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_GumException__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_GumException__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GumException'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Exception::Exception(std::string const,std::string const)\n"
    "    gum::Exception::Exception(std::string const)\n"
    "    gum::Exception::Exception()\n"
    "    gum::Exception::Exception(gum::Exception const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GumException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Exception *arg1 = (gum::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Exception, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GumException" "', argument " "1"" of type '" "gum::Exception *""'"); 
  }
  arg1 = reinterpret_cast< gum::Exception * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GumException_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Exception *arg1 = (gum::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GumException_what" "', argument " "1"" of type '" "gum::Exception const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Exception * >(argp1);
  {
    try {
      result = ((gum::Exception const *)arg1)->what();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GumException_errorContent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Exception *arg1 = (gum::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GumException_errorContent" "', argument " "1"" of type '" "gum::Exception const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Exception * >(argp1);
  {
    try {
      result = ((gum::Exception const *)arg1)->errorContent();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GumException_errorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Exception *arg1 = (gum::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GumException_errorType" "', argument " "1"" of type '" "gum::Exception const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Exception * >(argp1);
  {
    try {
      result = ((gum::Exception const *)arg1)->errorType();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GumException_errorCallStack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Exception *arg1 = (gum::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GumException_errorCallStack" "', argument " "1"" of type '" "gum::Exception const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Exception * >(argp1);
  {
    try {
      result = ((gum::Exception const *)arg1)->errorCallStack();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GumException_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__Exception, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GumException_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap___createMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  std::string *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject *swig_obj[4] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "__createMsg", 4, 4, swig_obj)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__createMsg" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__createMsg" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__createMsg" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__createMsg" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__createMsg" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "__createMsg" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__createMsg" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = gum::__createMsg((std::string const &)*arg1,(std::string const &)*arg2,arg3,(std::string const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IdError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::IdError *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_IdError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_IdError" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::IdError *)new gum::IdError(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IdError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IdError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::IdError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_IdError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::IdError *)new gum::IdError(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IdError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IdError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IdError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::IdError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__IdError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IdError" "', argument " "1"" of type '" "gum::IdError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IdError" "', argument " "1"" of type '" "gum::IdError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::IdError * >(argp1);
  {
    try {
      result = (gum::IdError *)new gum::IdError((gum::IdError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IdError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IdError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IdError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__IdError, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IdError__SWIG_2(self, argc, argv);
    }
  }
  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_IdError__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_IdError__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IdError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::IdError::IdError(std::string,std::string)\n"
    "    gum::IdError::IdError(std::string)\n"
    "    gum::IdError::IdError(gum::IdError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IdError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IdError *arg1 = (gum::IdError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IdError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IdError" "', argument " "1"" of type '" "gum::IdError *""'"); 
  }
  arg1 = reinterpret_cast< gum::IdError * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IdError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__IdError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IdError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FatalError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::FatalError *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FatalError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FatalError" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::FatalError *)new gum::FatalError(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FatalError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FatalError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::FatalError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FatalError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::FatalError *)new gum::FatalError(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FatalError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FatalError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::FatalError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::FatalError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__FatalError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FatalError" "', argument " "1"" of type '" "gum::FatalError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FatalError" "', argument " "1"" of type '" "gum::FatalError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::FatalError * >(argp1);
  {
    try {
      result = (gum::FatalError *)new gum::FatalError((gum::FatalError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FatalError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FatalError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FatalError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__FatalError, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FatalError__SWIG_2(self, argc, argv);
    }
  }
  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_FatalError__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FatalError__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FatalError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::FatalError::FatalError(std::string,std::string)\n"
    "    gum::FatalError::FatalError(std::string)\n"
    "    gum::FatalError::FatalError(gum::FatalError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::FatalError *arg1 = (gum::FatalError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__FatalError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FatalError" "', argument " "1"" of type '" "gum::FatalError *""'"); 
  }
  arg1 = reinterpret_cast< gum::FatalError * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FatalError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__FatalError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FatalError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NotImplementedYet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::NotImplementedYet *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NotImplementedYet" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NotImplementedYet" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::NotImplementedYet *)new gum::NotImplementedYet(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NotImplementedYet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotImplementedYet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::NotImplementedYet *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NotImplementedYet" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::NotImplementedYet *)new gum::NotImplementedYet(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NotImplementedYet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotImplementedYet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::NotImplementedYet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NotImplementedYet *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__NotImplementedYet,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NotImplementedYet" "', argument " "1"" of type '" "gum::NotImplementedYet const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NotImplementedYet" "', argument " "1"" of type '" "gum::NotImplementedYet const &""'"); 
  }
  arg1 = reinterpret_cast< gum::NotImplementedYet * >(argp1);
  {
    try {
      result = (gum::NotImplementedYet *)new gum::NotImplementedYet((gum::NotImplementedYet const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NotImplementedYet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotImplementedYet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NotImplementedYet", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__NotImplementedYet, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NotImplementedYet__SWIG_2(self, argc, argv);
    }
  }
  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_NotImplementedYet__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_NotImplementedYet__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NotImplementedYet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::NotImplementedYet::NotImplementedYet(std::string,std::string)\n"
    "    gum::NotImplementedYet::NotImplementedYet(std::string)\n"
    "    gum::NotImplementedYet::NotImplementedYet(gum::NotImplementedYet const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NotImplementedYet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::NotImplementedYet *arg1 = (gum::NotImplementedYet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NotImplementedYet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NotImplementedYet" "', argument " "1"" of type '" "gum::NotImplementedYet *""'"); 
  }
  arg1 = reinterpret_cast< gum::NotImplementedYet * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NotImplementedYet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__NotImplementedYet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NotImplementedYet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UndefinedIteratorValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::UndefinedIteratorValue *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_UndefinedIteratorValue" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_UndefinedIteratorValue" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::UndefinedIteratorValue *)new gum::UndefinedIteratorValue(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndefinedIteratorValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndefinedIteratorValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::UndefinedIteratorValue *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_UndefinedIteratorValue" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::UndefinedIteratorValue *)new gum::UndefinedIteratorValue(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndefinedIteratorValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndefinedIteratorValue__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UndefinedIteratorValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::UndefinedIteratorValue *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__UndefinedIteratorValue,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UndefinedIteratorValue" "', argument " "1"" of type '" "gum::UndefinedIteratorValue const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UndefinedIteratorValue" "', argument " "1"" of type '" "gum::UndefinedIteratorValue const &""'"); 
  }
  arg1 = reinterpret_cast< gum::UndefinedIteratorValue * >(argp1);
  {
    try {
      result = (gum::UndefinedIteratorValue *)new gum::UndefinedIteratorValue((gum::UndefinedIteratorValue const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndefinedIteratorValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndefinedIteratorValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UndefinedIteratorValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UndefinedIteratorValue, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UndefinedIteratorValue__SWIG_2(self, argc, argv);
    }
  }
  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_UndefinedIteratorValue__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UndefinedIteratorValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UndefinedIteratorValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UndefinedIteratorValue::UndefinedIteratorValue(std::string,std::string)\n"
    "    gum::UndefinedIteratorValue::UndefinedIteratorValue(std::string)\n"
    "    gum::UndefinedIteratorValue::UndefinedIteratorValue(gum::UndefinedIteratorValue const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UndefinedIteratorValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndefinedIteratorValue *arg1 = (gum::UndefinedIteratorValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndefinedIteratorValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UndefinedIteratorValue" "', argument " "1"" of type '" "gum::UndefinedIteratorValue *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndefinedIteratorValue * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UndefinedIteratorValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__UndefinedIteratorValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UndefinedIteratorValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UndefinedIteratorKey__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::UndefinedIteratorKey *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_UndefinedIteratorKey" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_UndefinedIteratorKey" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::UndefinedIteratorKey *)new gum::UndefinedIteratorKey(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndefinedIteratorKey, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndefinedIteratorKey__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::UndefinedIteratorKey *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_UndefinedIteratorKey" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::UndefinedIteratorKey *)new gum::UndefinedIteratorKey(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndefinedIteratorKey, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndefinedIteratorKey__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UndefinedIteratorKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::UndefinedIteratorKey *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__UndefinedIteratorKey,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UndefinedIteratorKey" "', argument " "1"" of type '" "gum::UndefinedIteratorKey const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UndefinedIteratorKey" "', argument " "1"" of type '" "gum::UndefinedIteratorKey const &""'"); 
  }
  arg1 = reinterpret_cast< gum::UndefinedIteratorKey * >(argp1);
  {
    try {
      result = (gum::UndefinedIteratorKey *)new gum::UndefinedIteratorKey((gum::UndefinedIteratorKey const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndefinedIteratorKey, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndefinedIteratorKey(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UndefinedIteratorKey", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UndefinedIteratorKey, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UndefinedIteratorKey__SWIG_2(self, argc, argv);
    }
  }
  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_UndefinedIteratorKey__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UndefinedIteratorKey__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UndefinedIteratorKey'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UndefinedIteratorKey::UndefinedIteratorKey(std::string,std::string)\n"
    "    gum::UndefinedIteratorKey::UndefinedIteratorKey(std::string)\n"
    "    gum::UndefinedIteratorKey::UndefinedIteratorKey(gum::UndefinedIteratorKey const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UndefinedIteratorKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndefinedIteratorKey *arg1 = (gum::UndefinedIteratorKey *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndefinedIteratorKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UndefinedIteratorKey" "', argument " "1"" of type '" "gum::UndefinedIteratorKey *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndefinedIteratorKey * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UndefinedIteratorKey_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__UndefinedIteratorKey, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UndefinedIteratorKey_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NullElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::NullElement *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NullElement" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NullElement" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::NullElement *)new gum::NullElement(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NullElement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NullElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::NullElement *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NullElement" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::NullElement *)new gum::NullElement(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NullElement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NullElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::NullElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NullElement *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__NullElement,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NullElement" "', argument " "1"" of type '" "gum::NullElement const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NullElement" "', argument " "1"" of type '" "gum::NullElement const &""'"); 
  }
  arg1 = reinterpret_cast< gum::NullElement * >(argp1);
  {
    try {
      result = (gum::NullElement *)new gum::NullElement((gum::NullElement const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NullElement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NullElement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NullElement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__NullElement, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NullElement__SWIG_2(self, argc, argv);
    }
  }
  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_NullElement__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_NullElement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NullElement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::NullElement::NullElement(std::string,std::string)\n"
    "    gum::NullElement::NullElement(std::string)\n"
    "    gum::NullElement::NullElement(gum::NullElement const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NullElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::NullElement *arg1 = (gum::NullElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NullElement, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NullElement" "', argument " "1"" of type '" "gum::NullElement *""'"); 
  }
  arg1 = reinterpret_cast< gum::NullElement * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NullElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__NullElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NullElement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UndefinedElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::UndefinedElement *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_UndefinedElement" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_UndefinedElement" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::UndefinedElement *)new gum::UndefinedElement(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndefinedElement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndefinedElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::UndefinedElement *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_UndefinedElement" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::UndefinedElement *)new gum::UndefinedElement(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndefinedElement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndefinedElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UndefinedElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::UndefinedElement *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__UndefinedElement,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UndefinedElement" "', argument " "1"" of type '" "gum::UndefinedElement const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UndefinedElement" "', argument " "1"" of type '" "gum::UndefinedElement const &""'"); 
  }
  arg1 = reinterpret_cast< gum::UndefinedElement * >(argp1);
  {
    try {
      result = (gum::UndefinedElement *)new gum::UndefinedElement((gum::UndefinedElement const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndefinedElement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndefinedElement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UndefinedElement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UndefinedElement, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UndefinedElement__SWIG_2(self, argc, argv);
    }
  }
  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_UndefinedElement__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UndefinedElement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UndefinedElement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UndefinedElement::UndefinedElement(std::string,std::string)\n"
    "    gum::UndefinedElement::UndefinedElement(std::string)\n"
    "    gum::UndefinedElement::UndefinedElement(gum::UndefinedElement const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UndefinedElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndefinedElement *arg1 = (gum::UndefinedElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndefinedElement, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UndefinedElement" "', argument " "1"" of type '" "gum::UndefinedElement *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndefinedElement * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UndefinedElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__UndefinedElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UndefinedElement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SizeError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::SizeError *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SizeError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SizeError" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::SizeError *)new gum::SizeError(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SizeError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SizeError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::SizeError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SizeError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::SizeError *)new gum::SizeError(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SizeError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SizeError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::SizeError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::SizeError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__SizeError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizeError" "', argument " "1"" of type '" "gum::SizeError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SizeError" "', argument " "1"" of type '" "gum::SizeError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::SizeError * >(argp1);
  {
    try {
      result = (gum::SizeError *)new gum::SizeError((gum::SizeError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SizeError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SizeError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SizeError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__SizeError, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SizeError__SWIG_2(self, argc, argv);
    }
  }
  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_SizeError__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SizeError__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SizeError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::SizeError::SizeError(std::string,std::string)\n"
    "    gum::SizeError::SizeError(std::string)\n"
    "    gum::SizeError::SizeError(gum::SizeError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SizeError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::SizeError *arg1 = (gum::SizeError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__SizeError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizeError" "', argument " "1"" of type '" "gum::SizeError *""'"); 
  }
  arg1 = reinterpret_cast< gum::SizeError * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SizeError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__SizeError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SizeError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EmptySet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::EmptySet *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EmptySet" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EmptySet" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::EmptySet *)new gum::EmptySet(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__EmptySet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EmptySet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::EmptySet *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EmptySet" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::EmptySet *)new gum::EmptySet(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__EmptySet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EmptySet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::EmptySet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::EmptySet *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__EmptySet,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EmptySet" "', argument " "1"" of type '" "gum::EmptySet const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EmptySet" "', argument " "1"" of type '" "gum::EmptySet const &""'"); 
  }
  arg1 = reinterpret_cast< gum::EmptySet * >(argp1);
  {
    try {
      result = (gum::EmptySet *)new gum::EmptySet((gum::EmptySet const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__EmptySet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EmptySet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EmptySet", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__EmptySet, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EmptySet__SWIG_2(self, argc, argv);
    }
  }
  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_EmptySet__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_EmptySet__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EmptySet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::EmptySet::EmptySet(std::string,std::string)\n"
    "    gum::EmptySet::EmptySet(std::string)\n"
    "    gum::EmptySet::EmptySet(gum::EmptySet const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EmptySet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::EmptySet *arg1 = (gum::EmptySet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__EmptySet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EmptySet" "', argument " "1"" of type '" "gum::EmptySet *""'"); 
  }
  arg1 = reinterpret_cast< gum::EmptySet * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EmptySet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__EmptySet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EmptySet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvalidArgumentsNumber__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::InvalidArgumentsNumber *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidArgumentsNumber" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidArgumentsNumber" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::InvalidArgumentsNumber *)new gum::InvalidArgumentsNumber(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidArgumentsNumber, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidArgumentsNumber__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::InvalidArgumentsNumber *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidArgumentsNumber" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::InvalidArgumentsNumber *)new gum::InvalidArgumentsNumber(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidArgumentsNumber, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidArgumentsNumber__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InvalidArgumentsNumber *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::InvalidArgumentsNumber *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__InvalidArgumentsNumber,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvalidArgumentsNumber" "', argument " "1"" of type '" "gum::InvalidArgumentsNumber const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvalidArgumentsNumber" "', argument " "1"" of type '" "gum::InvalidArgumentsNumber const &""'"); 
  }
  arg1 = reinterpret_cast< gum::InvalidArgumentsNumber * >(argp1);
  {
    try {
      result = (gum::InvalidArgumentsNumber *)new gum::InvalidArgumentsNumber((gum::InvalidArgumentsNumber const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidArgumentsNumber, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidArgumentsNumber(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvalidArgumentsNumber", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__InvalidArgumentsNumber, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvalidArgumentsNumber__SWIG_2(self, argc, argv);
    }
  }
  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_InvalidArgumentsNumber__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InvalidArgumentsNumber__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvalidArgumentsNumber'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InvalidArgumentsNumber::InvalidArgumentsNumber(std::string,std::string)\n"
    "    gum::InvalidArgumentsNumber::InvalidArgumentsNumber(std::string)\n"
    "    gum::InvalidArgumentsNumber::InvalidArgumentsNumber(gum::InvalidArgumentsNumber const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidArgumentsNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InvalidArgumentsNumber *arg1 = (gum::InvalidArgumentsNumber *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InvalidArgumentsNumber, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvalidArgumentsNumber" "', argument " "1"" of type '" "gum::InvalidArgumentsNumber *""'"); 
  }
  arg1 = reinterpret_cast< gum::InvalidArgumentsNumber * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvalidArgumentsNumber_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__InvalidArgumentsNumber, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvalidArgumentsNumber_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvalidArgument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::InvalidArgument *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidArgument" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidArgument" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::InvalidArgument *)new gum::InvalidArgument(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidArgument, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidArgument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::InvalidArgument *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidArgument" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::InvalidArgument *)new gum::InvalidArgument(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidArgument, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidArgument__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InvalidArgument *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::InvalidArgument *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__InvalidArgument,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvalidArgument" "', argument " "1"" of type '" "gum::InvalidArgument const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvalidArgument" "', argument " "1"" of type '" "gum::InvalidArgument const &""'"); 
  }
  arg1 = reinterpret_cast< gum::InvalidArgument * >(argp1);
  {
    try {
      result = (gum::InvalidArgument *)new gum::InvalidArgument((gum::InvalidArgument const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidArgument, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidArgument(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvalidArgument", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__InvalidArgument, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvalidArgument__SWIG_2(self, argc, argv);
    }
  }
  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_InvalidArgument__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InvalidArgument__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvalidArgument'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InvalidArgument::InvalidArgument(std::string,std::string)\n"
    "    gum::InvalidArgument::InvalidArgument(std::string)\n"
    "    gum::InvalidArgument::InvalidArgument(gum::InvalidArgument const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidArgument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InvalidArgument *arg1 = (gum::InvalidArgument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InvalidArgument, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvalidArgument" "', argument " "1"" of type '" "gum::InvalidArgument *""'"); 
  }
  arg1 = reinterpret_cast< gum::InvalidArgument * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvalidArgument_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__InvalidArgument, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvalidArgument_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IOError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::IOError *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_IOError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_IOError" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::IOError *)new gum::IOError(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IOError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::IOError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_IOError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::IOError *)new gum::IOError(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IOError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IOError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::IOError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__IOError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IOError" "', argument " "1"" of type '" "gum::IOError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IOError" "', argument " "1"" of type '" "gum::IOError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::IOError * >(argp1);
  {
    try {
      result = (gum::IOError *)new gum::IOError((gum::IOError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IOError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IOError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__IOError, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOError__SWIG_2(self, argc, argv);
    }
  }
  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_IOError__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_IOError__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IOError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::IOError::IOError(std::string,std::string)\n"
    "    gum::IOError::IOError(std::string)\n"
    "    gum::IOError::IOError(gum::IOError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IOError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IOError *arg1 = (gum::IOError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IOError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOError" "', argument " "1"" of type '" "gum::IOError *""'"); 
  }
  arg1 = reinterpret_cast< gum::IOError * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IOError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__IOError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IOError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FormatNotFound__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::FormatNotFound *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FormatNotFound" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FormatNotFound" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::FormatNotFound *)new gum::FormatNotFound(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FormatNotFound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FormatNotFound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::FormatNotFound *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FormatNotFound" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::FormatNotFound *)new gum::FormatNotFound(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FormatNotFound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FormatNotFound__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::FormatNotFound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::FormatNotFound *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__FormatNotFound,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FormatNotFound" "', argument " "1"" of type '" "gum::FormatNotFound const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FormatNotFound" "', argument " "1"" of type '" "gum::FormatNotFound const &""'"); 
  }
  arg1 = reinterpret_cast< gum::FormatNotFound * >(argp1);
  {
    try {
      result = (gum::FormatNotFound *)new gum::FormatNotFound((gum::FormatNotFound const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FormatNotFound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FormatNotFound(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FormatNotFound", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__FormatNotFound, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FormatNotFound__SWIG_2(self, argc, argv);
    }
  }
  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_FormatNotFound__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FormatNotFound__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FormatNotFound'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::FormatNotFound::FormatNotFound(std::string,std::string)\n"
    "    gum::FormatNotFound::FormatNotFound(std::string)\n"
    "    gum::FormatNotFound::FormatNotFound(gum::FormatNotFound const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FormatNotFound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::FormatNotFound *arg1 = (gum::FormatNotFound *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__FormatNotFound, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FormatNotFound" "', argument " "1"" of type '" "gum::FormatNotFound *""'"); 
  }
  arg1 = reinterpret_cast< gum::FormatNotFound * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FormatNotFound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__FormatNotFound, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FormatNotFound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OperationNotAllowed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::OperationNotAllowed *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OperationNotAllowed" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OperationNotAllowed" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::OperationNotAllowed *)new gum::OperationNotAllowed(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OperationNotAllowed, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OperationNotAllowed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::OperationNotAllowed *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OperationNotAllowed" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::OperationNotAllowed *)new gum::OperationNotAllowed(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OperationNotAllowed, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OperationNotAllowed__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::OperationNotAllowed *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::OperationNotAllowed *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__OperationNotAllowed,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperationNotAllowed" "', argument " "1"" of type '" "gum::OperationNotAllowed const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperationNotAllowed" "', argument " "1"" of type '" "gum::OperationNotAllowed const &""'"); 
  }
  arg1 = reinterpret_cast< gum::OperationNotAllowed * >(argp1);
  {
    try {
      result = (gum::OperationNotAllowed *)new gum::OperationNotAllowed((gum::OperationNotAllowed const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OperationNotAllowed, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OperationNotAllowed(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OperationNotAllowed", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__OperationNotAllowed, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OperationNotAllowed__SWIG_2(self, argc, argv);
    }
  }
  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_OperationNotAllowed__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_OperationNotAllowed__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OperationNotAllowed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::OperationNotAllowed::OperationNotAllowed(std::string,std::string)\n"
    "    gum::OperationNotAllowed::OperationNotAllowed(std::string)\n"
    "    gum::OperationNotAllowed::OperationNotAllowed(gum::OperationNotAllowed const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OperationNotAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::OperationNotAllowed *arg1 = (gum::OperationNotAllowed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__OperationNotAllowed, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OperationNotAllowed" "', argument " "1"" of type '" "gum::OperationNotAllowed *""'"); 
  }
  arg1 = reinterpret_cast< gum::OperationNotAllowed * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OperationNotAllowed_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__OperationNotAllowed, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OperationNotAllowed_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NotFound__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::NotFound *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NotFound" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NotFound" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::NotFound *)new gum::NotFound(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NotFound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotFound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::NotFound *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NotFound" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::NotFound *)new gum::NotFound(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NotFound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotFound__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::NotFound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NotFound *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__NotFound,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NotFound" "', argument " "1"" of type '" "gum::NotFound const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NotFound" "', argument " "1"" of type '" "gum::NotFound const &""'"); 
  }
  arg1 = reinterpret_cast< gum::NotFound * >(argp1);
  {
    try {
      result = (gum::NotFound *)new gum::NotFound((gum::NotFound const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NotFound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotFound(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NotFound", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__NotFound, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NotFound__SWIG_2(self, argc, argv);
    }
  }
  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_NotFound__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_NotFound__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NotFound'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::NotFound::NotFound(std::string,std::string)\n"
    "    gum::NotFound::NotFound(std::string)\n"
    "    gum::NotFound::NotFound(gum::NotFound const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NotFound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::NotFound *arg1 = (gum::NotFound *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NotFound, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NotFound" "', argument " "1"" of type '" "gum::NotFound *""'"); 
  }
  arg1 = reinterpret_cast< gum::NotFound * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NotFound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__NotFound, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NotFound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ReferenceError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::ReferenceError *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ReferenceError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ReferenceError" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::ReferenceError *)new gum::ReferenceError(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ReferenceError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReferenceError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::ReferenceError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ReferenceError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::ReferenceError *)new gum::ReferenceError(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ReferenceError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReferenceError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ReferenceError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::ReferenceError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__ReferenceError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ReferenceError" "', argument " "1"" of type '" "gum::ReferenceError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ReferenceError" "', argument " "1"" of type '" "gum::ReferenceError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::ReferenceError * >(argp1);
  {
    try {
      result = (gum::ReferenceError *)new gum::ReferenceError((gum::ReferenceError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ReferenceError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReferenceError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ReferenceError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__ReferenceError, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ReferenceError__SWIG_2(self, argc, argv);
    }
  }
  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_ReferenceError__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ReferenceError__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ReferenceError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ReferenceError::ReferenceError(std::string,std::string)\n"
    "    gum::ReferenceError::ReferenceError(std::string)\n"
    "    gum::ReferenceError::ReferenceError(gum::ReferenceError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ReferenceError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ReferenceError *arg1 = (gum::ReferenceError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ReferenceError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReferenceError" "', argument " "1"" of type '" "gum::ReferenceError *""'"); 
  }
  arg1 = reinterpret_cast< gum::ReferenceError * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ReferenceError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__ReferenceError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ReferenceError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OutOfBounds__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::OutOfBounds *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OutOfBounds" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OutOfBounds" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::OutOfBounds *)new gum::OutOfBounds(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OutOfBounds, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutOfBounds__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::OutOfBounds *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OutOfBounds" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::OutOfBounds *)new gum::OutOfBounds(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OutOfBounds, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutOfBounds__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::OutOfBounds *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::OutOfBounds *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__OutOfBounds,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OutOfBounds" "', argument " "1"" of type '" "gum::OutOfBounds const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OutOfBounds" "', argument " "1"" of type '" "gum::OutOfBounds const &""'"); 
  }
  arg1 = reinterpret_cast< gum::OutOfBounds * >(argp1);
  {
    try {
      result = (gum::OutOfBounds *)new gum::OutOfBounds((gum::OutOfBounds const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OutOfBounds, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutOfBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OutOfBounds", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__OutOfBounds, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OutOfBounds__SWIG_2(self, argc, argv);
    }
  }
  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_OutOfBounds__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_OutOfBounds__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OutOfBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::OutOfBounds::OutOfBounds(std::string,std::string)\n"
    "    gum::OutOfBounds::OutOfBounds(std::string)\n"
    "    gum::OutOfBounds::OutOfBounds(gum::OutOfBounds const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OutOfBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::OutOfBounds *arg1 = (gum::OutOfBounds *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__OutOfBounds, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OutOfBounds" "', argument " "1"" of type '" "gum::OutOfBounds *""'"); 
  }
  arg1 = reinterpret_cast< gum::OutOfBounds * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OutOfBounds_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__OutOfBounds, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OutOfBounds_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OutOfLowerBound__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::OutOfLowerBound *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OutOfLowerBound" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OutOfLowerBound" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::OutOfLowerBound *)new gum::OutOfLowerBound(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OutOfLowerBound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutOfLowerBound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::OutOfLowerBound *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OutOfLowerBound" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::OutOfLowerBound *)new gum::OutOfLowerBound(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OutOfLowerBound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutOfLowerBound__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::OutOfLowerBound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::OutOfLowerBound *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__OutOfLowerBound,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OutOfLowerBound" "', argument " "1"" of type '" "gum::OutOfLowerBound const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OutOfLowerBound" "', argument " "1"" of type '" "gum::OutOfLowerBound const &""'"); 
  }
  arg1 = reinterpret_cast< gum::OutOfLowerBound * >(argp1);
  {
    try {
      result = (gum::OutOfLowerBound *)new gum::OutOfLowerBound((gum::OutOfLowerBound const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OutOfLowerBound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutOfLowerBound(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OutOfLowerBound", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__OutOfLowerBound, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OutOfLowerBound__SWIG_2(self, argc, argv);
    }
  }
  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_OutOfLowerBound__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_OutOfLowerBound__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OutOfLowerBound'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::OutOfLowerBound::OutOfLowerBound(std::string,std::string)\n"
    "    gum::OutOfLowerBound::OutOfLowerBound(std::string)\n"
    "    gum::OutOfLowerBound::OutOfLowerBound(gum::OutOfLowerBound const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OutOfLowerBound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::OutOfLowerBound *arg1 = (gum::OutOfLowerBound *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__OutOfLowerBound, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OutOfLowerBound" "', argument " "1"" of type '" "gum::OutOfLowerBound *""'"); 
  }
  arg1 = reinterpret_cast< gum::OutOfLowerBound * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OutOfLowerBound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__OutOfLowerBound, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OutOfLowerBound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OutOfUpperBound__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::OutOfUpperBound *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OutOfUpperBound" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OutOfUpperBound" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::OutOfUpperBound *)new gum::OutOfUpperBound(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OutOfUpperBound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutOfUpperBound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::OutOfUpperBound *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OutOfUpperBound" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::OutOfUpperBound *)new gum::OutOfUpperBound(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OutOfUpperBound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutOfUpperBound__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::OutOfUpperBound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::OutOfUpperBound *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__OutOfUpperBound,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OutOfUpperBound" "', argument " "1"" of type '" "gum::OutOfUpperBound const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OutOfUpperBound" "', argument " "1"" of type '" "gum::OutOfUpperBound const &""'"); 
  }
  arg1 = reinterpret_cast< gum::OutOfUpperBound * >(argp1);
  {
    try {
      result = (gum::OutOfUpperBound *)new gum::OutOfUpperBound((gum::OutOfUpperBound const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__OutOfUpperBound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutOfUpperBound(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OutOfUpperBound", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__OutOfUpperBound, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OutOfUpperBound__SWIG_2(self, argc, argv);
    }
  }
  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_OutOfUpperBound__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_OutOfUpperBound__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OutOfUpperBound'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::OutOfUpperBound::OutOfUpperBound(std::string,std::string)\n"
    "    gum::OutOfUpperBound::OutOfUpperBound(std::string)\n"
    "    gum::OutOfUpperBound::OutOfUpperBound(gum::OutOfUpperBound const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OutOfUpperBound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::OutOfUpperBound *arg1 = (gum::OutOfUpperBound *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__OutOfUpperBound, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OutOfUpperBound" "', argument " "1"" of type '" "gum::OutOfUpperBound *""'"); 
  }
  arg1 = reinterpret_cast< gum::OutOfUpperBound * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OutOfUpperBound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__OutOfUpperBound, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OutOfUpperBound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DuplicateElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::DuplicateElement *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DuplicateElement" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DuplicateElement" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::DuplicateElement *)new gum::DuplicateElement(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DuplicateElement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplicateElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::DuplicateElement *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DuplicateElement" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::DuplicateElement *)new gum::DuplicateElement(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DuplicateElement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplicateElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DuplicateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::DuplicateElement *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__DuplicateElement,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DuplicateElement" "', argument " "1"" of type '" "gum::DuplicateElement const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DuplicateElement" "', argument " "1"" of type '" "gum::DuplicateElement const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DuplicateElement * >(argp1);
  {
    try {
      result = (gum::DuplicateElement *)new gum::DuplicateElement((gum::DuplicateElement const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DuplicateElement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplicateElement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DuplicateElement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DuplicateElement, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DuplicateElement__SWIG_2(self, argc, argv);
    }
  }
  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_DuplicateElement__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DuplicateElement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DuplicateElement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DuplicateElement::DuplicateElement(std::string,std::string)\n"
    "    gum::DuplicateElement::DuplicateElement(std::string)\n"
    "    gum::DuplicateElement::DuplicateElement(gum::DuplicateElement const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DuplicateElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DuplicateElement *arg1 = (gum::DuplicateElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DuplicateElement, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DuplicateElement" "', argument " "1"" of type '" "gum::DuplicateElement *""'"); 
  }
  arg1 = reinterpret_cast< gum::DuplicateElement * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DuplicateElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__DuplicateElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DuplicateElement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DuplicateLabel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::DuplicateLabel *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DuplicateLabel" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DuplicateLabel" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::DuplicateLabel *)new gum::DuplicateLabel(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DuplicateLabel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplicateLabel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::DuplicateLabel *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DuplicateLabel" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::DuplicateLabel *)new gum::DuplicateLabel(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DuplicateLabel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplicateLabel__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DuplicateLabel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::DuplicateLabel *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__DuplicateLabel,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DuplicateLabel" "', argument " "1"" of type '" "gum::DuplicateLabel const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DuplicateLabel" "', argument " "1"" of type '" "gum::DuplicateLabel const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DuplicateLabel * >(argp1);
  {
    try {
      result = (gum::DuplicateLabel *)new gum::DuplicateLabel((gum::DuplicateLabel const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DuplicateLabel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplicateLabel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DuplicateLabel", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DuplicateLabel, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DuplicateLabel__SWIG_2(self, argc, argv);
    }
  }
  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_DuplicateLabel__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DuplicateLabel__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DuplicateLabel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DuplicateLabel::DuplicateLabel(std::string,std::string)\n"
    "    gum::DuplicateLabel::DuplicateLabel(std::string)\n"
    "    gum::DuplicateLabel::DuplicateLabel(gum::DuplicateLabel const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DuplicateLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DuplicateLabel *arg1 = (gum::DuplicateLabel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DuplicateLabel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DuplicateLabel" "', argument " "1"" of type '" "gum::DuplicateLabel *""'"); 
  }
  arg1 = reinterpret_cast< gum::DuplicateLabel * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DuplicateLabel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__DuplicateLabel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DuplicateLabel_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GraphError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::GraphError *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_GraphError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_GraphError" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::GraphError *)new gum::GraphError(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__GraphError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GraphError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::GraphError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_GraphError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::GraphError *)new gum::GraphError(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__GraphError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GraphError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GraphError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::GraphError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__GraphError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GraphError" "', argument " "1"" of type '" "gum::GraphError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GraphError" "', argument " "1"" of type '" "gum::GraphError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphError * >(argp1);
  {
    try {
      result = (gum::GraphError *)new gum::GraphError((gum::GraphError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__GraphError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GraphError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GraphError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__GraphError, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GraphError__SWIG_2(self, argc, argv);
    }
  }
  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_GraphError__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_GraphError__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GraphError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GraphError::GraphError(std::string,std::string)\n"
    "    gum::GraphError::GraphError(std::string)\n"
    "    gum::GraphError::GraphError(gum::GraphError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GraphError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GraphError *arg1 = (gum::GraphError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GraphError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GraphError" "', argument " "1"" of type '" "gum::GraphError *""'"); 
  }
  arg1 = reinterpret_cast< gum::GraphError * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GraphError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__GraphError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GraphError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NoNeighbour__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::NoNeighbour *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NoNeighbour" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NoNeighbour" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::NoNeighbour *)new gum::NoNeighbour(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NoNeighbour, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNeighbour__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::NoNeighbour *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NoNeighbour" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::NoNeighbour *)new gum::NoNeighbour(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NoNeighbour, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNeighbour__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::NoNeighbour *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NoNeighbour *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__NoNeighbour,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoNeighbour" "', argument " "1"" of type '" "gum::NoNeighbour const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoNeighbour" "', argument " "1"" of type '" "gum::NoNeighbour const &""'"); 
  }
  arg1 = reinterpret_cast< gum::NoNeighbour * >(argp1);
  {
    try {
      result = (gum::NoNeighbour *)new gum::NoNeighbour((gum::NoNeighbour const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NoNeighbour, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNeighbour(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NoNeighbour", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__NoNeighbour, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNeighbour__SWIG_2(self, argc, argv);
    }
  }
  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_NoNeighbour__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_NoNeighbour__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NoNeighbour'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::NoNeighbour::NoNeighbour(std::string,std::string)\n"
    "    gum::NoNeighbour::NoNeighbour(std::string)\n"
    "    gum::NoNeighbour::NoNeighbour(gum::NoNeighbour const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoNeighbour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::NoNeighbour *arg1 = (gum::NoNeighbour *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NoNeighbour, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoNeighbour" "', argument " "1"" of type '" "gum::NoNeighbour *""'"); 
  }
  arg1 = reinterpret_cast< gum::NoNeighbour * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoNeighbour_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__NoNeighbour, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NoNeighbour_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NoParent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::NoParent *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NoParent" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NoParent" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::NoParent *)new gum::NoParent(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NoParent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoParent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::NoParent *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NoParent" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::NoParent *)new gum::NoParent(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NoParent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoParent__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::NoParent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NoParent *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__NoParent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoParent" "', argument " "1"" of type '" "gum::NoParent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoParent" "', argument " "1"" of type '" "gum::NoParent const &""'"); 
  }
  arg1 = reinterpret_cast< gum::NoParent * >(argp1);
  {
    try {
      result = (gum::NoParent *)new gum::NoParent((gum::NoParent const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NoParent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoParent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NoParent", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__NoParent, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoParent__SWIG_2(self, argc, argv);
    }
  }
  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_NoParent__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_NoParent__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NoParent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::NoParent::NoParent(std::string,std::string)\n"
    "    gum::NoParent::NoParent(std::string)\n"
    "    gum::NoParent::NoParent(gum::NoParent const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::NoParent *arg1 = (gum::NoParent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NoParent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoParent" "', argument " "1"" of type '" "gum::NoParent *""'"); 
  }
  arg1 = reinterpret_cast< gum::NoParent * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoParent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__NoParent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NoParent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NoChild__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::NoChild *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NoChild" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NoChild" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::NoChild *)new gum::NoChild(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NoChild, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoChild__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::NoChild *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NoChild" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::NoChild *)new gum::NoChild(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NoChild, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoChild__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::NoChild *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NoChild *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__NoChild,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoChild" "', argument " "1"" of type '" "gum::NoChild const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoChild" "', argument " "1"" of type '" "gum::NoChild const &""'"); 
  }
  arg1 = reinterpret_cast< gum::NoChild * >(argp1);
  {
    try {
      result = (gum::NoChild *)new gum::NoChild((gum::NoChild const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NoChild, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoChild(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NoChild", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__NoChild, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoChild__SWIG_2(self, argc, argv);
    }
  }
  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_NoChild__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_NoChild__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NoChild'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::NoChild::NoChild(std::string,std::string)\n"
    "    gum::NoChild::NoChild(std::string)\n"
    "    gum::NoChild::NoChild(gum::NoChild const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::NoChild *arg1 = (gum::NoChild *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__NoChild, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoChild" "', argument " "1"" of type '" "gum::NoChild *""'"); 
  }
  arg1 = reinterpret_cast< gum::NoChild * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoChild_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__NoChild, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NoChild_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvalidEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::InvalidEdge *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidEdge" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidEdge" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::InvalidEdge *)new gum::InvalidEdge(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidEdge, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::InvalidEdge *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidEdge" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::InvalidEdge *)new gum::InvalidEdge(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidEdge, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidEdge__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InvalidEdge *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::InvalidEdge *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__InvalidEdge,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvalidEdge" "', argument " "1"" of type '" "gum::InvalidEdge const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvalidEdge" "', argument " "1"" of type '" "gum::InvalidEdge const &""'"); 
  }
  arg1 = reinterpret_cast< gum::InvalidEdge * >(argp1);
  {
    try {
      result = (gum::InvalidEdge *)new gum::InvalidEdge((gum::InvalidEdge const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidEdge, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidEdge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvalidEdge", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__InvalidEdge, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvalidEdge__SWIG_2(self, argc, argv);
    }
  }
  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_InvalidEdge__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InvalidEdge__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvalidEdge'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InvalidEdge::InvalidEdge(std::string,std::string)\n"
    "    gum::InvalidEdge::InvalidEdge(std::string)\n"
    "    gum::InvalidEdge::InvalidEdge(gum::InvalidEdge const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InvalidEdge *arg1 = (gum::InvalidEdge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InvalidEdge, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvalidEdge" "', argument " "1"" of type '" "gum::InvalidEdge *""'"); 
  }
  arg1 = reinterpret_cast< gum::InvalidEdge * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvalidEdge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__InvalidEdge, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvalidEdge_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvalidArc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::InvalidArc *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidArc" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidArc" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::InvalidArc *)new gum::InvalidArc(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidArc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidArc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::InvalidArc *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidArc" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::InvalidArc *)new gum::InvalidArc(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidArc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidArc__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InvalidArc *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::InvalidArc *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__InvalidArc,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvalidArc" "', argument " "1"" of type '" "gum::InvalidArc const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvalidArc" "', argument " "1"" of type '" "gum::InvalidArc const &""'"); 
  }
  arg1 = reinterpret_cast< gum::InvalidArc * >(argp1);
  {
    try {
      result = (gum::InvalidArc *)new gum::InvalidArc((gum::InvalidArc const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidArc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvalidArc", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__InvalidArc, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvalidArc__SWIG_2(self, argc, argv);
    }
  }
  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_InvalidArc__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InvalidArc__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvalidArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InvalidArc::InvalidArc(std::string,std::string)\n"
    "    gum::InvalidArc::InvalidArc(std::string)\n"
    "    gum::InvalidArc::InvalidArc(gum::InvalidArc const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InvalidArc *arg1 = (gum::InvalidArc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InvalidArc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvalidArc" "', argument " "1"" of type '" "gum::InvalidArc *""'"); 
  }
  arg1 = reinterpret_cast< gum::InvalidArc * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvalidArc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__InvalidArc, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvalidArc_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvalidNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::InvalidNode *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidNode" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidNode" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::InvalidNode *)new gum::InvalidNode(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::InvalidNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidNode" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::InvalidNode *)new gum::InvalidNode(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidNode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InvalidNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::InvalidNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__InvalidNode,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvalidNode" "', argument " "1"" of type '" "gum::InvalidNode const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvalidNode" "', argument " "1"" of type '" "gum::InvalidNode const &""'"); 
  }
  arg1 = reinterpret_cast< gum::InvalidNode * >(argp1);
  {
    try {
      result = (gum::InvalidNode *)new gum::InvalidNode((gum::InvalidNode const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvalidNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__InvalidNode, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvalidNode__SWIG_2(self, argc, argv);
    }
  }
  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_InvalidNode__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InvalidNode__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvalidNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InvalidNode::InvalidNode(std::string,std::string)\n"
    "    gum::InvalidNode::InvalidNode(std::string)\n"
    "    gum::InvalidNode::InvalidNode(gum::InvalidNode const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InvalidNode *arg1 = (gum::InvalidNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InvalidNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvalidNode" "', argument " "1"" of type '" "gum::InvalidNode *""'"); 
  }
  arg1 = reinterpret_cast< gum::InvalidNode * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvalidNode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__InvalidNode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvalidNode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EmptyBSTree__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::EmptyBSTree *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EmptyBSTree" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EmptyBSTree" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::EmptyBSTree *)new gum::EmptyBSTree(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__EmptyBSTree, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EmptyBSTree__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::EmptyBSTree *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EmptyBSTree" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::EmptyBSTree *)new gum::EmptyBSTree(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__EmptyBSTree, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EmptyBSTree__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::EmptyBSTree *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::EmptyBSTree *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__EmptyBSTree,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EmptyBSTree" "', argument " "1"" of type '" "gum::EmptyBSTree const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EmptyBSTree" "', argument " "1"" of type '" "gum::EmptyBSTree const &""'"); 
  }
  arg1 = reinterpret_cast< gum::EmptyBSTree * >(argp1);
  {
    try {
      result = (gum::EmptyBSTree *)new gum::EmptyBSTree((gum::EmptyBSTree const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__EmptyBSTree, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EmptyBSTree(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EmptyBSTree", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__EmptyBSTree, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EmptyBSTree__SWIG_2(self, argc, argv);
    }
  }
  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_EmptyBSTree__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_EmptyBSTree__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EmptyBSTree'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::EmptyBSTree::EmptyBSTree(std::string,std::string)\n"
    "    gum::EmptyBSTree::EmptyBSTree(std::string)\n"
    "    gum::EmptyBSTree::EmptyBSTree(gum::EmptyBSTree const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EmptyBSTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::EmptyBSTree *arg1 = (gum::EmptyBSTree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__EmptyBSTree, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EmptyBSTree" "', argument " "1"" of type '" "gum::EmptyBSTree *""'"); 
  }
  arg1 = reinterpret_cast< gum::EmptyBSTree * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EmptyBSTree_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__EmptyBSTree, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EmptyBSTree_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DefaultInLabel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::DefaultInLabel *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DefaultInLabel" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DefaultInLabel" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::DefaultInLabel *)new gum::DefaultInLabel(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DefaultInLabel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultInLabel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::DefaultInLabel *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DefaultInLabel" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::DefaultInLabel *)new gum::DefaultInLabel(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DefaultInLabel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultInLabel__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DefaultInLabel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::DefaultInLabel *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__DefaultInLabel,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DefaultInLabel" "', argument " "1"" of type '" "gum::DefaultInLabel const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultInLabel" "', argument " "1"" of type '" "gum::DefaultInLabel const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DefaultInLabel * >(argp1);
  {
    try {
      result = (gum::DefaultInLabel *)new gum::DefaultInLabel((gum::DefaultInLabel const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DefaultInLabel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultInLabel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DefaultInLabel", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DefaultInLabel, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DefaultInLabel__SWIG_2(self, argc, argv);
    }
  }
  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_DefaultInLabel__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DefaultInLabel__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DefaultInLabel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DefaultInLabel::DefaultInLabel(std::string,std::string)\n"
    "    gum::DefaultInLabel::DefaultInLabel(std::string)\n"
    "    gum::DefaultInLabel::DefaultInLabel(gum::DefaultInLabel const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DefaultInLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DefaultInLabel *arg1 = (gum::DefaultInLabel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DefaultInLabel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultInLabel" "', argument " "1"" of type '" "gum::DefaultInLabel *""'"); 
  }
  arg1 = reinterpret_cast< gum::DefaultInLabel * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DefaultInLabel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__DefaultInLabel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DefaultInLabel_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvalidDirectedCycle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::InvalidDirectedCycle *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidDirectedCycle" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidDirectedCycle" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::InvalidDirectedCycle *)new gum::InvalidDirectedCycle(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidDirectedCycle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidDirectedCycle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::InvalidDirectedCycle *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_InvalidDirectedCycle" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::InvalidDirectedCycle *)new gum::InvalidDirectedCycle(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidDirectedCycle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidDirectedCycle__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InvalidDirectedCycle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::InvalidDirectedCycle *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__InvalidDirectedCycle,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvalidDirectedCycle" "', argument " "1"" of type '" "gum::InvalidDirectedCycle const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvalidDirectedCycle" "', argument " "1"" of type '" "gum::InvalidDirectedCycle const &""'"); 
  }
  arg1 = reinterpret_cast< gum::InvalidDirectedCycle * >(argp1);
  {
    try {
      result = (gum::InvalidDirectedCycle *)new gum::InvalidDirectedCycle((gum::InvalidDirectedCycle const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InvalidDirectedCycle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidDirectedCycle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvalidDirectedCycle", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__InvalidDirectedCycle, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvalidDirectedCycle__SWIG_2(self, argc, argv);
    }
  }
  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_InvalidDirectedCycle__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InvalidDirectedCycle__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvalidDirectedCycle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InvalidDirectedCycle::InvalidDirectedCycle(std::string,std::string)\n"
    "    gum::InvalidDirectedCycle::InvalidDirectedCycle(std::string)\n"
    "    gum::InvalidDirectedCycle::InvalidDirectedCycle(gum::InvalidDirectedCycle const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidDirectedCycle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InvalidDirectedCycle *arg1 = (gum::InvalidDirectedCycle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InvalidDirectedCycle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvalidDirectedCycle" "', argument " "1"" of type '" "gum::InvalidDirectedCycle *""'"); 
  }
  arg1 = reinterpret_cast< gum::InvalidDirectedCycle * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvalidDirectedCycle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__InvalidDirectedCycle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvalidDirectedCycle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CPTError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::CPTError *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_CPTError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_CPTError" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::CPTError *)new gum::CPTError(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CPTError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPTError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::CPTError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_CPTError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::CPTError *)new gum::CPTError(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CPTError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPTError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CPTError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::CPTError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CPTError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CPTError" "', argument " "1"" of type '" "gum::CPTError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPTError" "', argument " "1"" of type '" "gum::CPTError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CPTError * >(argp1);
  {
    try {
      result = (gum::CPTError *)new gum::CPTError((gum::CPTError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CPTError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPTError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CPTError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__CPTError, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CPTError__SWIG_2(self, argc, argv);
    }
  }
  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_CPTError__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CPTError__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CPTError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CPTError::CPTError(std::string,std::string)\n"
    "    gum::CPTError::CPTError(std::string)\n"
    "    gum::CPTError::CPTError(gum::CPTError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CPTError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CPTError *arg1 = (gum::CPTError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CPTError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPTError" "', argument " "1"" of type '" "gum::CPTError *""'"); 
  }
  arg1 = reinterpret_cast< gum::CPTError * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CPTError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__CPTError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CPTError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CPTNoSumTo1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::CPTNoSumTo1 *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_CPTNoSumTo1" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_CPTNoSumTo1" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::CPTNoSumTo1 *)new gum::CPTNoSumTo1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CPTNoSumTo1, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPTNoSumTo1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::CPTNoSumTo1 *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_CPTNoSumTo1" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::CPTNoSumTo1 *)new gum::CPTNoSumTo1(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CPTNoSumTo1, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPTNoSumTo1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CPTNoSumTo1 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::CPTNoSumTo1 *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CPTNoSumTo1,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CPTNoSumTo1" "', argument " "1"" of type '" "gum::CPTNoSumTo1 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPTNoSumTo1" "', argument " "1"" of type '" "gum::CPTNoSumTo1 const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CPTNoSumTo1 * >(argp1);
  {
    try {
      result = (gum::CPTNoSumTo1 *)new gum::CPTNoSumTo1((gum::CPTNoSumTo1 const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CPTNoSumTo1, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPTNoSumTo1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CPTNoSumTo1", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__CPTNoSumTo1, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CPTNoSumTo1__SWIG_2(self, argc, argv);
    }
  }
  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_CPTNoSumTo1__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CPTNoSumTo1__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CPTNoSumTo1'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CPTNoSumTo1::CPTNoSumTo1(std::string,std::string)\n"
    "    gum::CPTNoSumTo1::CPTNoSumTo1(std::string)\n"
    "    gum::CPTNoSumTo1::CPTNoSumTo1(gum::CPTNoSumTo1 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CPTNoSumTo1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CPTNoSumTo1 *arg1 = (gum::CPTNoSumTo1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CPTNoSumTo1, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPTNoSumTo1" "', argument " "1"" of type '" "gum::CPTNoSumTo1 *""'"); 
  }
  arg1 = reinterpret_cast< gum::CPTNoSumTo1 * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CPTNoSumTo1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__CPTNoSumTo1, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CPTNoSumTo1_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IncompatibleEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::IncompatibleEvidence *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_IncompatibleEvidence" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_IncompatibleEvidence" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::IncompatibleEvidence *)new gum::IncompatibleEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IncompatibleEvidence, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncompatibleEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::IncompatibleEvidence *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_IncompatibleEvidence" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::IncompatibleEvidence *)new gum::IncompatibleEvidence(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IncompatibleEvidence, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncompatibleEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IncompatibleEvidence *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::IncompatibleEvidence *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__IncompatibleEvidence,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IncompatibleEvidence" "', argument " "1"" of type '" "gum::IncompatibleEvidence const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IncompatibleEvidence" "', argument " "1"" of type '" "gum::IncompatibleEvidence const &""'"); 
  }
  arg1 = reinterpret_cast< gum::IncompatibleEvidence * >(argp1);
  {
    try {
      result = (gum::IncompatibleEvidence *)new gum::IncompatibleEvidence((gum::IncompatibleEvidence const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IncompatibleEvidence, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncompatibleEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IncompatibleEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__IncompatibleEvidence, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IncompatibleEvidence__SWIG_2(self, argc, argv);
    }
  }
  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_IncompatibleEvidence__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_IncompatibleEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IncompatibleEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::IncompatibleEvidence::IncompatibleEvidence(std::string,std::string)\n"
    "    gum::IncompatibleEvidence::IncompatibleEvidence(std::string)\n"
    "    gum::IncompatibleEvidence::IncompatibleEvidence(gum::IncompatibleEvidence const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IncompatibleEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IncompatibleEvidence *arg1 = (gum::IncompatibleEvidence *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IncompatibleEvidence, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IncompatibleEvidence" "', argument " "1"" of type '" "gum::IncompatibleEvidence *""'"); 
  }
  arg1 = reinterpret_cast< gum::IncompatibleEvidence * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IncompatibleEvidence_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__IncompatibleEvidence, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IncompatibleEvidence_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FactoryError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::FactoryError *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FactoryError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FactoryError" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::FactoryError *)new gum::FactoryError(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FactoryError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FactoryError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::FactoryError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FactoryError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::FactoryError *)new gum::FactoryError(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FactoryError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FactoryError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::FactoryError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::FactoryError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__FactoryError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FactoryError" "', argument " "1"" of type '" "gum::FactoryError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FactoryError" "', argument " "1"" of type '" "gum::FactoryError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::FactoryError * >(argp1);
  {
    try {
      result = (gum::FactoryError *)new gum::FactoryError((gum::FactoryError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FactoryError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FactoryError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FactoryError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__FactoryError, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FactoryError__SWIG_2(self, argc, argv);
    }
  }
  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_FactoryError__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FactoryError__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FactoryError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::FactoryError::FactoryError(std::string,std::string)\n"
    "    gum::FactoryError::FactoryError(std::string)\n"
    "    gum::FactoryError::FactoryError(gum::FactoryError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FactoryError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::FactoryError *arg1 = (gum::FactoryError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__FactoryError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FactoryError" "', argument " "1"" of type '" "gum::FactoryError *""'"); 
  }
  arg1 = reinterpret_cast< gum::FactoryError * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FactoryError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__FactoryError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FactoryError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FactoryInvalidState__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::FactoryInvalidState *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FactoryInvalidState" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FactoryInvalidState" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::FactoryInvalidState *)new gum::FactoryInvalidState(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FactoryInvalidState, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FactoryInvalidState__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::FactoryInvalidState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FactoryInvalidState" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::FactoryInvalidState *)new gum::FactoryInvalidState(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FactoryInvalidState, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FactoryInvalidState__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::FactoryInvalidState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::FactoryInvalidState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__FactoryInvalidState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FactoryInvalidState" "', argument " "1"" of type '" "gum::FactoryInvalidState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FactoryInvalidState" "', argument " "1"" of type '" "gum::FactoryInvalidState const &""'"); 
  }
  arg1 = reinterpret_cast< gum::FactoryInvalidState * >(argp1);
  {
    try {
      result = (gum::FactoryInvalidState *)new gum::FactoryInvalidState((gum::FactoryInvalidState const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__FactoryInvalidState, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FactoryInvalidState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FactoryInvalidState", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__FactoryInvalidState, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FactoryInvalidState__SWIG_2(self, argc, argv);
    }
  }
  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_FactoryInvalidState__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FactoryInvalidState__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FactoryInvalidState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::FactoryInvalidState::FactoryInvalidState(std::string,std::string)\n"
    "    gum::FactoryInvalidState::FactoryInvalidState(std::string)\n"
    "    gum::FactoryInvalidState::FactoryInvalidState(gum::FactoryInvalidState const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FactoryInvalidState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::FactoryInvalidState *arg1 = (gum::FactoryInvalidState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__FactoryInvalidState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FactoryInvalidState" "', argument " "1"" of type '" "gum::FactoryInvalidState *""'"); 
  }
  arg1 = reinterpret_cast< gum::FactoryInvalidState * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FactoryInvalidState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__FactoryInvalidState, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FactoryInvalidState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_WrongType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::WrongType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_WrongType" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_WrongType" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::WrongType *)new gum::WrongType(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__WrongType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WrongType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::WrongType *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_WrongType" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::WrongType *)new gum::WrongType(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__WrongType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WrongType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WrongType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::WrongType *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__WrongType,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WrongType" "', argument " "1"" of type '" "gum::WrongType const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_WrongType" "', argument " "1"" of type '" "gum::WrongType const &""'"); 
  }
  arg1 = reinterpret_cast< gum::WrongType * >(argp1);
  {
    try {
      result = (gum::WrongType *)new gum::WrongType((gum::WrongType const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__WrongType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WrongType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_WrongType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__WrongType, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_WrongType__SWIG_2(self, argc, argv);
    }
  }
  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_WrongType__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_WrongType__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_WrongType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::WrongType::WrongType(std::string,std::string)\n"
    "    gum::WrongType::WrongType(std::string)\n"
    "    gum::WrongType::WrongType(gum::WrongType const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_WrongType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WrongType *arg1 = (gum::WrongType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WrongType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WrongType" "', argument " "1"" of type '" "gum::WrongType *""'"); 
  }
  arg1 = reinterpret_cast< gum::WrongType * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *WrongType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__WrongType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *WrongType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_WrongClassElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::WrongClassElement *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_WrongClassElement" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_WrongClassElement" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::WrongClassElement *)new gum::WrongClassElement(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__WrongClassElement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WrongClassElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::WrongClassElement *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_WrongClassElement" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::WrongClassElement *)new gum::WrongClassElement(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__WrongClassElement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WrongClassElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WrongClassElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::WrongClassElement *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__WrongClassElement,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WrongClassElement" "', argument " "1"" of type '" "gum::WrongClassElement const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_WrongClassElement" "', argument " "1"" of type '" "gum::WrongClassElement const &""'"); 
  }
  arg1 = reinterpret_cast< gum::WrongClassElement * >(argp1);
  {
    try {
      result = (gum::WrongClassElement *)new gum::WrongClassElement((gum::WrongClassElement const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__WrongClassElement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WrongClassElement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_WrongClassElement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__WrongClassElement, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_WrongClassElement__SWIG_2(self, argc, argv);
    }
  }
  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_WrongClassElement__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_WrongClassElement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_WrongClassElement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::WrongClassElement::WrongClassElement(std::string,std::string)\n"
    "    gum::WrongClassElement::WrongClassElement(std::string)\n"
    "    gum::WrongClassElement::WrongClassElement(gum::WrongClassElement const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_WrongClassElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WrongClassElement *arg1 = (gum::WrongClassElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WrongClassElement, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WrongClassElement" "', argument " "1"" of type '" "gum::WrongClassElement *""'"); 
  }
  arg1 = reinterpret_cast< gum::WrongClassElement * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *WrongClassElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__WrongClassElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *WrongClassElement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TypeError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::TypeError *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_TypeError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_TypeError" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::TypeError *)new gum::TypeError(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TypeError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TypeError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::TypeError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_TypeError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::TypeError *)new gum::TypeError(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TypeError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TypeError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::TypeError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::TypeError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__TypeError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TypeError" "', argument " "1"" of type '" "gum::TypeError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TypeError" "', argument " "1"" of type '" "gum::TypeError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::TypeError * >(argp1);
  {
    try {
      result = (gum::TypeError *)new gum::TypeError((gum::TypeError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__TypeError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TypeError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TypeError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__TypeError, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TypeError__SWIG_2(self, argc, argv);
    }
  }
  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_TypeError__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TypeError__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TypeError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::TypeError::TypeError(std::string,std::string)\n"
    "    gum::TypeError::TypeError(std::string)\n"
    "    gum::TypeError::TypeError(gum::TypeError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TypeError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::TypeError *arg1 = (gum::TypeError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__TypeError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TypeError" "', argument " "1"" of type '" "gum::TypeError *""'"); 
  }
  arg1 = reinterpret_cast< gum::TypeError * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TypeError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__TypeError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TypeError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LearningError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::LearningError *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LearningError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LearningError" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::LearningError *)new gum::LearningError(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LearningError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LearningError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::LearningError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LearningError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::LearningError *)new gum::LearningError(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LearningError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LearningError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LearningError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::LearningError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__LearningError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LearningError" "', argument " "1"" of type '" "gum::LearningError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LearningError" "', argument " "1"" of type '" "gum::LearningError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::LearningError * >(argp1);
  {
    try {
      result = (gum::LearningError *)new gum::LearningError((gum::LearningError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LearningError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LearningError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LearningError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__LearningError, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LearningError__SWIG_2(self, argc, argv);
    }
  }
  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_LearningError__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_LearningError__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LearningError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LearningError::LearningError(std::string,std::string)\n"
    "    gum::LearningError::LearningError(std::string)\n"
    "    gum::LearningError::LearningError(gum::LearningError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LearningError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LearningError *arg1 = (gum::LearningError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LearningError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LearningError" "', argument " "1"" of type '" "gum::LearningError *""'"); 
  }
  arg1 = reinterpret_cast< gum::LearningError * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LearningError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__LearningError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LearningError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IncompatibleScoreApriori__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::IncompatibleScoreApriori *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_IncompatibleScoreApriori" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_IncompatibleScoreApriori" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::IncompatibleScoreApriori *)new gum::IncompatibleScoreApriori(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IncompatibleScoreApriori, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncompatibleScoreApriori__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::IncompatibleScoreApriori *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_IncompatibleScoreApriori" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::IncompatibleScoreApriori *)new gum::IncompatibleScoreApriori(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IncompatibleScoreApriori, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncompatibleScoreApriori__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IncompatibleScoreApriori *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::IncompatibleScoreApriori *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__IncompatibleScoreApriori,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IncompatibleScoreApriori" "', argument " "1"" of type '" "gum::IncompatibleScoreApriori const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IncompatibleScoreApriori" "', argument " "1"" of type '" "gum::IncompatibleScoreApriori const &""'"); 
  }
  arg1 = reinterpret_cast< gum::IncompatibleScoreApriori * >(argp1);
  {
    try {
      result = (gum::IncompatibleScoreApriori *)new gum::IncompatibleScoreApriori((gum::IncompatibleScoreApriori const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IncompatibleScoreApriori, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncompatibleScoreApriori(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IncompatibleScoreApriori", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__IncompatibleScoreApriori, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IncompatibleScoreApriori__SWIG_2(self, argc, argv);
    }
  }
  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_IncompatibleScoreApriori__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_IncompatibleScoreApriori__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IncompatibleScoreApriori'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::IncompatibleScoreApriori::IncompatibleScoreApriori(std::string,std::string)\n"
    "    gum::IncompatibleScoreApriori::IncompatibleScoreApriori(std::string)\n"
    "    gum::IncompatibleScoreApriori::IncompatibleScoreApriori(gum::IncompatibleScoreApriori const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IncompatibleScoreApriori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IncompatibleScoreApriori *arg1 = (gum::IncompatibleScoreApriori *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IncompatibleScoreApriori, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IncompatibleScoreApriori" "', argument " "1"" of type '" "gum::IncompatibleScoreApriori *""'"); 
  }
  arg1 = reinterpret_cast< gum::IncompatibleScoreApriori * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IncompatibleScoreApriori_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__IncompatibleScoreApriori, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IncompatibleScoreApriori_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PossiblyIncompatibleScoreApriori__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::PossiblyIncompatibleScoreApriori *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PossiblyIncompatibleScoreApriori" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PossiblyIncompatibleScoreApriori" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::PossiblyIncompatibleScoreApriori *)new gum::PossiblyIncompatibleScoreApriori(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PossiblyIncompatibleScoreApriori, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PossiblyIncompatibleScoreApriori__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::PossiblyIncompatibleScoreApriori *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PossiblyIncompatibleScoreApriori" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::PossiblyIncompatibleScoreApriori *)new gum::PossiblyIncompatibleScoreApriori(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PossiblyIncompatibleScoreApriori, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PossiblyIncompatibleScoreApriori__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::PossiblyIncompatibleScoreApriori *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::PossiblyIncompatibleScoreApriori *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__PossiblyIncompatibleScoreApriori,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PossiblyIncompatibleScoreApriori" "', argument " "1"" of type '" "gum::PossiblyIncompatibleScoreApriori const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PossiblyIncompatibleScoreApriori" "', argument " "1"" of type '" "gum::PossiblyIncompatibleScoreApriori const &""'"); 
  }
  arg1 = reinterpret_cast< gum::PossiblyIncompatibleScoreApriori * >(argp1);
  {
    try {
      result = (gum::PossiblyIncompatibleScoreApriori *)new gum::PossiblyIncompatibleScoreApriori((gum::PossiblyIncompatibleScoreApriori const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PossiblyIncompatibleScoreApriori, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PossiblyIncompatibleScoreApriori(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PossiblyIncompatibleScoreApriori", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__PossiblyIncompatibleScoreApriori, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PossiblyIncompatibleScoreApriori__SWIG_2(self, argc, argv);
    }
  }
  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_PossiblyIncompatibleScoreApriori__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_PossiblyIncompatibleScoreApriori__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PossiblyIncompatibleScoreApriori'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::PossiblyIncompatibleScoreApriori::PossiblyIncompatibleScoreApriori(std::string,std::string)\n"
    "    gum::PossiblyIncompatibleScoreApriori::PossiblyIncompatibleScoreApriori(std::string)\n"
    "    gum::PossiblyIncompatibleScoreApriori::PossiblyIncompatibleScoreApriori(gum::PossiblyIncompatibleScoreApriori const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PossiblyIncompatibleScoreApriori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::PossiblyIncompatibleScoreApriori *arg1 = (gum::PossiblyIncompatibleScoreApriori *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PossiblyIncompatibleScoreApriori, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PossiblyIncompatibleScoreApriori" "', argument " "1"" of type '" "gum::PossiblyIncompatibleScoreApriori *""'"); 
  }
  arg1 = reinterpret_cast< gum::PossiblyIncompatibleScoreApriori * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PossiblyIncompatibleScoreApriori_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__PossiblyIncompatibleScoreApriori, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PossiblyIncompatibleScoreApriori_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DatabaseError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::DatabaseError *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DatabaseError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DatabaseError" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::DatabaseError *)new gum::DatabaseError(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DatabaseError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::DatabaseError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DatabaseError" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::DatabaseError *)new gum::DatabaseError(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DatabaseError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DatabaseError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::DatabaseError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__DatabaseError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DatabaseError" "', argument " "1"" of type '" "gum::DatabaseError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DatabaseError" "', argument " "1"" of type '" "gum::DatabaseError const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DatabaseError * >(argp1);
  {
    try {
      result = (gum::DatabaseError *)new gum::DatabaseError((gum::DatabaseError const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DatabaseError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DatabaseError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DatabaseError, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DatabaseError__SWIG_2(self, argc, argv);
    }
  }
  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_DatabaseError__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DatabaseError__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DatabaseError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DatabaseError::DatabaseError(std::string,std::string)\n"
    "    gum::DatabaseError::DatabaseError(std::string)\n"
    "    gum::DatabaseError::DatabaseError(gum::DatabaseError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DatabaseError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DatabaseError *arg1 = (gum::DatabaseError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DatabaseError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DatabaseError" "', argument " "1"" of type '" "gum::DatabaseError *""'"); 
  }
  arg1 = reinterpret_cast< gum::DatabaseError * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DatabaseError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__DatabaseError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DatabaseError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MissingVariableInDatabase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::MissingVariableInDatabase *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MissingVariableInDatabase" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MissingVariableInDatabase" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::MissingVariableInDatabase *)new gum::MissingVariableInDatabase(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MissingVariableInDatabase, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MissingVariableInDatabase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::MissingVariableInDatabase *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MissingVariableInDatabase" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::MissingVariableInDatabase *)new gum::MissingVariableInDatabase(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MissingVariableInDatabase, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MissingVariableInDatabase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MissingVariableInDatabase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::MissingVariableInDatabase *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__MissingVariableInDatabase,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MissingVariableInDatabase" "', argument " "1"" of type '" "gum::MissingVariableInDatabase const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MissingVariableInDatabase" "', argument " "1"" of type '" "gum::MissingVariableInDatabase const &""'"); 
  }
  arg1 = reinterpret_cast< gum::MissingVariableInDatabase * >(argp1);
  {
    try {
      result = (gum::MissingVariableInDatabase *)new gum::MissingVariableInDatabase((gum::MissingVariableInDatabase const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MissingVariableInDatabase, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MissingVariableInDatabase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MissingVariableInDatabase", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__MissingVariableInDatabase, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MissingVariableInDatabase__SWIG_2(self, argc, argv);
    }
  }
  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_MissingVariableInDatabase__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MissingVariableInDatabase__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MissingVariableInDatabase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MissingVariableInDatabase::MissingVariableInDatabase(std::string,std::string)\n"
    "    gum::MissingVariableInDatabase::MissingVariableInDatabase(std::string)\n"
    "    gum::MissingVariableInDatabase::MissingVariableInDatabase(gum::MissingVariableInDatabase const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MissingVariableInDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MissingVariableInDatabase *arg1 = (gum::MissingVariableInDatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MissingVariableInDatabase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MissingVariableInDatabase" "', argument " "1"" of type '" "gum::MissingVariableInDatabase *""'"); 
  }
  arg1 = reinterpret_cast< gum::MissingVariableInDatabase * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MissingVariableInDatabase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__MissingVariableInDatabase, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MissingVariableInDatabase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MissingValueInDatabase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::MissingValueInDatabase *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MissingValueInDatabase" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MissingValueInDatabase" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::MissingValueInDatabase *)new gum::MissingValueInDatabase(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MissingValueInDatabase, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MissingValueInDatabase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::MissingValueInDatabase *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MissingValueInDatabase" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::MissingValueInDatabase *)new gum::MissingValueInDatabase(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MissingValueInDatabase, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MissingValueInDatabase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MissingValueInDatabase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::MissingValueInDatabase *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__MissingValueInDatabase,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MissingValueInDatabase" "', argument " "1"" of type '" "gum::MissingValueInDatabase const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MissingValueInDatabase" "', argument " "1"" of type '" "gum::MissingValueInDatabase const &""'"); 
  }
  arg1 = reinterpret_cast< gum::MissingValueInDatabase * >(argp1);
  {
    try {
      result = (gum::MissingValueInDatabase *)new gum::MissingValueInDatabase((gum::MissingValueInDatabase const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MissingValueInDatabase, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MissingValueInDatabase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MissingValueInDatabase", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__MissingValueInDatabase, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MissingValueInDatabase__SWIG_2(self, argc, argv);
    }
  }
  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_MissingValueInDatabase__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MissingValueInDatabase__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MissingValueInDatabase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MissingValueInDatabase::MissingValueInDatabase(std::string,std::string)\n"
    "    gum::MissingValueInDatabase::MissingValueInDatabase(std::string)\n"
    "    gum::MissingValueInDatabase::MissingValueInDatabase(gum::MissingValueInDatabase const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MissingValueInDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MissingValueInDatabase *arg1 = (gum::MissingValueInDatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MissingValueInDatabase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MissingValueInDatabase" "', argument " "1"" of type '" "gum::MissingValueInDatabase *""'"); 
  }
  arg1 = reinterpret_cast< gum::MissingValueInDatabase * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MissingValueInDatabase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__MissingValueInDatabase, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MissingValueInDatabase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UnknownLabelInDatabase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  gum::UnknownLabelInDatabase *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_UnknownLabelInDatabase" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_UnknownLabelInDatabase" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::UnknownLabelInDatabase *)new gum::UnknownLabelInDatabase(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnknownLabelInDatabase, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnknownLabelInDatabase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::UnknownLabelInDatabase *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_UnknownLabelInDatabase" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::UnknownLabelInDatabase *)new gum::UnknownLabelInDatabase(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnknownLabelInDatabase, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnknownLabelInDatabase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UnknownLabelInDatabase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::UnknownLabelInDatabase *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__UnknownLabelInDatabase,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnknownLabelInDatabase" "', argument " "1"" of type '" "gum::UnknownLabelInDatabase const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnknownLabelInDatabase" "', argument " "1"" of type '" "gum::UnknownLabelInDatabase const &""'"); 
  }
  arg1 = reinterpret_cast< gum::UnknownLabelInDatabase * >(argp1);
  {
    try {
      result = (gum::UnknownLabelInDatabase *)new gum::UnknownLabelInDatabase((gum::UnknownLabelInDatabase const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UnknownLabelInDatabase, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnknownLabelInDatabase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UnknownLabelInDatabase", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UnknownLabelInDatabase, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnknownLabelInDatabase__SWIG_2(self, argc, argv);
    }
  }
  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_UnknownLabelInDatabase__SWIG_1(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UnknownLabelInDatabase__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UnknownLabelInDatabase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UnknownLabelInDatabase::UnknownLabelInDatabase(std::string,std::string)\n"
    "    gum::UnknownLabelInDatabase::UnknownLabelInDatabase(std::string)\n"
    "    gum::UnknownLabelInDatabase::UnknownLabelInDatabase(gum::UnknownLabelInDatabase const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnknownLabelInDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UnknownLabelInDatabase *arg1 = (gum::UnknownLabelInDatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UnknownLabelInDatabase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnknownLabelInDatabase" "', argument " "1"" of type '" "gum::UnknownLabelInDatabase *""'"); 
  }
  arg1 = reinterpret_cast< gum::UnknownLabelInDatabase * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnknownLabelInDatabase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__UnknownLabelInDatabase, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UnknownLabelInDatabase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SyntaxError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  gum::Size arg2 ;
  gum::Size arg3 ;
  std::string arg4 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::SyntaxError *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SyntaxError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SyntaxError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SyntaxError" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SyntaxError" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SyntaxError" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::SyntaxError *)new gum::SyntaxError((std::string const &)*arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SyntaxError, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SyntaxError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  gum::Size arg2 ;
  gum::Size arg3 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::SyntaxError *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SyntaxError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SyntaxError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SyntaxError" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SyntaxError" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  {
    try {
      result = (gum::SyntaxError *)new gum::SyntaxError((std::string const &)*arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SyntaxError, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SyntaxError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SyntaxError", 0, 4, argv))) SWIG_fail;
  --argc;
  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_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SyntaxError__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  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_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(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_new_SyntaxError__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SyntaxError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::SyntaxError::SyntaxError(std::string const &,gum::Size,gum::Size,std::string)\n"
    "    gum::SyntaxError::SyntaxError(std::string const &,gum::Size,gum::Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SyntaxError_col(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::SyntaxError *arg1 = (gum::SyntaxError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__SyntaxError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SyntaxError_col" "', argument " "1"" of type '" "gum::SyntaxError const *""'"); 
  }
  arg1 = reinterpret_cast< gum::SyntaxError * >(argp1);
  {
    try {
      result = ((gum::SyntaxError const *)arg1)->col();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SyntaxError_line(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::SyntaxError *arg1 = (gum::SyntaxError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__SyntaxError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SyntaxError_line" "', argument " "1"" of type '" "gum::SyntaxError const *""'"); 
  }
  arg1 = reinterpret_cast< gum::SyntaxError * >(argp1);
  {
    try {
      result = ((gum::SyntaxError const *)arg1)->line();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SyntaxError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::SyntaxError *arg1 = (gum::SyntaxError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__SyntaxError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SyntaxError" "', argument " "1"" of type '" "gum::SyntaxError *""'"); 
  }
  arg1 = reinterpret_cast< gum::SyntaxError * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SyntaxError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__SyntaxError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SyntaxError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_randomValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  gum::Idx result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "randomValue" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  {
    try {
      result = gum::randomValue(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randomValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::Idx result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = gum::randomValue();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randomValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "randomValue", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_randomValue__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_randomValue__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'randomValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::randomValue(gum::Size const)\n"
    "    gum::randomValue()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_randomProba(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "randomProba", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (double)gum::randomProba();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randomGeneratorSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "randomGeneratorSeed", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (unsigned int)gum::randomGeneratorSeed();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_initRandom__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "initRandom" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      gum::initRandom(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_initRandom__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      gum::initRandom();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_initRandom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "initRandom", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_initRandom__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_initRandom__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'initRandom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::initRandom(unsigned int)\n"
    "    gum::initRandom()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_getRandomGenerator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  std::default_random_engine result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getRandomGenerator" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = gum::getRandomGenerator(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::default_random_engine(static_cast< const std::default_random_engine& >(result))), SWIGTYPE_p_std__default_random_engine, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_getRandomGenerator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::default_random_engine result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = gum::getRandomGenerator();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::default_random_engine(static_cast< const std::default_random_engine& >(result))), SWIGTYPE_p_std__default_random_engine, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_getRandomGenerator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "getRandomGenerator", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_getRandomGenerator__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_getRandomGenerator__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'getRandomGenerator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::getRandomGenerator(unsigned int)\n"
    "    gum::getRandomGenerator()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_isOMP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "isOMP", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (bool)gum::isOMP();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_setNumberOfThreads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "setNumberOfThreads" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      gum::setNumberOfThreads(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_getMaxNumberOfThreads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "getMaxNumberOfThreads", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (unsigned int)gum::getMaxNumberOfThreads();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_getThreadNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "getThreadNumber", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (unsigned int)gum::getThreadNumber();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_getNumberOfRunningThreads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "getNumberOfRunningThreads", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (unsigned int)gum::getNumberOfRunningThreads();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_getNumberOfLogicalProcessors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "getNumberOfLogicalProcessors", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (unsigned int)gum::getNumberOfLogicalProcessors();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_setNestedParallelism(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "setNestedParallelism" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      gum::setNestedParallelism(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_getNestedParallelism(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "getNestedParallelism", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (bool)gum::getNestedParallelism();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_setDynamicThreadsNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "setDynamicThreadsNumber" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      gum::setDynamicThreadsNumber(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_getDynamicThreadsNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "getDynamicThreadsNumber", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (bool)gum::getDynamicThreadsNumber();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Variable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = (gum::Variable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Variable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Variable" "', argument " "1"" of type '" "gum::Variable *""'"); 
  }
  arg1 = reinterpret_cast< gum::Variable * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Variable_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = (gum::Variable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Variable *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Variable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Variable_clone" "', argument " "1"" of type '" "gum::Variable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Variable * >(argp1);
  {
    try {
      result = (gum::Variable *)((gum::Variable const *)arg1)->clone();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Variable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Variable___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = (gum::Variable *) 0 ;
  gum::Variable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Variable___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Variable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Variable___eq__" "', argument " "1"" of type '" "gum::Variable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Variable * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Variable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Variable___eq__" "', argument " "2"" of type '" "gum::Variable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Variable___eq__" "', argument " "2"" of type '" "gum::Variable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Variable * >(argp2);
  {
    try {
      result = (bool)((gum::Variable const *)arg1)->operator ==((gum::Variable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Variable___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = (gum::Variable *) 0 ;
  gum::Variable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Variable___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Variable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Variable___ne__" "', argument " "1"" of type '" "gum::Variable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Variable * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Variable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Variable___ne__" "', argument " "2"" of type '" "gum::Variable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Variable___ne__" "', argument " "2"" of type '" "gum::Variable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Variable * >(argp2);
  {
    try {
      result = (bool)((gum::Variable const *)arg1)->operator !=((gum::Variable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Variable_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = (gum::Variable *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Variable_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Variable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Variable_setName" "', argument " "1"" of type '" "gum::Variable *""'"); 
  }
  arg1 = reinterpret_cast< gum::Variable * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Variable_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Variable_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->setName((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Variable_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = (gum::Variable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Variable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Variable_name" "', argument " "1"" of type '" "gum::Variable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Variable * >(argp1);
  {
    try {
      result = (std::string *) &((gum::Variable const *)arg1)->name();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Variable_setDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = (gum::Variable *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Variable_setDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Variable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Variable_setDescription" "', argument " "1"" of type '" "gum::Variable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Variable * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Variable_setDescription" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Variable_setDescription" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      ((gum::Variable const *)arg1)->setDescription((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Variable_description(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = (gum::Variable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Variable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Variable_description" "', argument " "1"" of type '" "gum::Variable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Variable * >(argp1);
  {
    try {
      result = (std::string *) &((gum::Variable const *)arg1)->description();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Variable_varType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = (gum::Variable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VarType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Variable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Variable_varType" "', argument " "1"" of type '" "gum::Variable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Variable * >(argp1);
  {
    try {
      result = (gum::VarType)((gum::Variable const *)arg1)->varType();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Variable_domain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Variable *arg1 = (gum::Variable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Variable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Variable_domain" "', argument " "1"" of type '" "gum::Variable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Variable * >(argp1);
  {
    try {
      result = ((gum::Variable const *)arg1)->domain();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Variable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__Variable, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_DiscreteVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscreteVariable" "', argument " "1"" of type '" "gum::DiscreteVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DiscreteVariable *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable_clone" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = (gum::DiscreteVariable *)((gum::DiscreteVariable const *)arg1)->clone();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable_empty" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = (bool)((gum::DiscreteVariable const *)arg1)->empty();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_domainSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable_domainSize" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = ((gum::DiscreteVariable const *)arg1)->domainSize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_labels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable_labels" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = ((gum::DiscreteVariable const *)arg1)->labels();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_numerical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "DiscreteVariable_numerical", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable_numerical" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscreteVariable_numerical" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = (double)((gum::DiscreteVariable const *)arg1)->numerical(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_varType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VarType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable_varType" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = (gum::VarType)((gum::DiscreteVariable const *)arg1)->varType();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "DiscreteVariable___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable___eq__" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteVariable___eq__" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteVariable___eq__" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (bool)((gum::DiscreteVariable const *)arg1)->operator ==((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "DiscreteVariable___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable___ne__" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteVariable___ne__" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteVariable___ne__" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (bool)((gum::DiscreteVariable const *)arg1)->operator !=((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  if (!SWIG_Python_UnpackTuple(args, "DiscreteVariable_index", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable_index" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteVariable_index" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteVariable_index" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::DiscreteVariable const *)arg1)->index((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_label(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "DiscreteVariable_label", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable_label" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscreteVariable_label" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = ((gum::DiscreteVariable const *)arg1)->label(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_toStringWithDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable_toStringWithDescription" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = ((gum::DiscreteVariable const *)arg1)->toStringWithDescription();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_domain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable_domain" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = ((gum::DiscreteVariable const *)arg1)->domain();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable___repr__" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = gum_DiscreteVariable___repr__((gum::DiscreteVariable const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable___str__" "', argument " "1"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = gum_DiscreteVariable___str__((gum::DiscreteVariable const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_toLabelizedVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< gum::LabelizedVariable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable_toLabelizedVar" "', argument " "1"" of type '" "gum::DiscreteVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = gum_DiscreteVariable_toLabelizedVar(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::LabelizedVariable(static_cast< const gum::LabelizedVariable& >(result))), SWIGTYPE_p_gum__LabelizedVariable, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_toRangeVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< gum::RangeVariable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable_toRangeVar" "', argument " "1"" of type '" "gum::DiscreteVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = gum_DiscreteVariable_toRangeVar(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::RangeVariable(static_cast< const gum::RangeVariable& >(result))), SWIGTYPE_p_gum__RangeVariable, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscreteVariable_toDiscretizedVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscreteVariable *arg1 = (gum::DiscreteVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< gum::DiscretizedVariable< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteVariable_toDiscretizedVar" "', argument " "1"" of type '" "gum::DiscreteVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscreteVariable * >(argp1);
  {
    try {
      result = gum_DiscreteVariable_toDiscretizedVar(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::DiscretizedVariable< double >(static_cast< const gum::DiscretizedVariable< double >& >(result))), SWIGTYPE_p_gum__DiscretizedVariableT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DiscreteVariable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__DiscreteVariable, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LabelizedVariable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  gum::Size arg3 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::LabelizedVariable *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LabelizedVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LabelizedVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LabelizedVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LabelizedVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LabelizedVariable" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  {
    try {
      result = (gum::LabelizedVariable *)new gum::LabelizedVariable((std::string const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LabelizedVariable, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LabelizedVariable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  gum::LabelizedVariable *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LabelizedVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LabelizedVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LabelizedVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LabelizedVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::LabelizedVariable *)new gum::LabelizedVariable((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LabelizedVariable, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LabelizedVariable__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::LabelizedVariable *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LabelizedVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LabelizedVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::LabelizedVariable *)new gum::LabelizedVariable((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LabelizedVariable, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LabelizedVariable__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::LabelizedVariable *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LabelizedVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LabelizedVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LabelizedVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LabelizedVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LabelizedVariable" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LabelizedVariable" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (gum::LabelizedVariable *)new gum::LabelizedVariable((std::string const &)*arg1,(std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LabelizedVariable, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LabelizedVariable__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::LabelizedVariable *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__LabelizedVariable,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LabelizedVariable" "', argument " "1"" of type '" "gum::LabelizedVariable const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LabelizedVariable" "', argument " "1"" of type '" "gum::LabelizedVariable const &""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  {
    try {
      result = (gum::LabelizedVariable *)new gum::LabelizedVariable((gum::LabelizedVariable const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LabelizedVariable, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LabelizedVariable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LabelizedVariable", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__LabelizedVariable, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LabelizedVariable__SWIG_4(self, argc, argv);
    }
  }
  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_LabelizedVariable__SWIG_2(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_LabelizedVariable__SWIG_1(self, argc, argv);
      }
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_LabelizedVariable__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LabelizedVariable__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LabelizedVariable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LabelizedVariable::LabelizedVariable(std::string const &,std::string const &,gum::Size const)\n"
    "    gum::LabelizedVariable::LabelizedVariable(std::string const &,std::string const &)\n"
    "    gum::LabelizedVariable::LabelizedVariable(std::string const &)\n"
    "    gum::LabelizedVariable::LabelizedVariable(std::string const &,std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::LabelizedVariable::LabelizedVariable(gum::LabelizedVariable const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LabelizedVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = (gum::LabelizedVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LabelizedVariable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LabelizedVariable" "', argument " "1"" of type '" "gum::LabelizedVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = (gum::LabelizedVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::LabelizedVariable *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LabelizedVariable_clone" "', argument " "1"" of type '" "gum::LabelizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  {
    try {
      result = (gum::LabelizedVariable *)((gum::LabelizedVariable const *)arg1)->clone();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = (gum::LabelizedVariable *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  if (!SWIG_Python_UnpackTuple(args, "LabelizedVariable_index", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LabelizedVariable_index" "', argument " "1"" of type '" "gum::LabelizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LabelizedVariable_index" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LabelizedVariable_index" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::LabelizedVariable const *)arg1)->index((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_isLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = (gum::LabelizedVariable *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "LabelizedVariable_isLabel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LabelizedVariable_isLabel" "', argument " "1"" of type '" "gum::LabelizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LabelizedVariable_isLabel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LabelizedVariable_isLabel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)((gum::LabelizedVariable const *)arg1)->isLabel((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_addLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = (gum::LabelizedVariable *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::LabelizedVariable *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "LabelizedVariable_addLabel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LabelizedVariable_addLabel" "', argument " "1"" of type '" "gum::LabelizedVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LabelizedVariable_addLabel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LabelizedVariable_addLabel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::LabelizedVariable *) &(arg1)->addLabel((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_changeLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = (gum::LabelizedVariable *) 0 ;
  gum::Idx arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LabelizedVariable_changeLabel", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LabelizedVariable_changeLabel" "', argument " "1"" of type '" "gum::LabelizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LabelizedVariable_changeLabel" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LabelizedVariable_changeLabel" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LabelizedVariable_changeLabel" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      ((gum::LabelizedVariable const *)arg1)->changeLabel(arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_eraseLabels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = (gum::LabelizedVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LabelizedVariable_eraseLabels" "', argument " "1"" of type '" "gum::LabelizedVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  {
    try {
      (arg1)->eraseLabels();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_label(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = (gum::LabelizedVariable *) 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "LabelizedVariable_label", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LabelizedVariable_label" "', argument " "1"" of type '" "gum::LabelizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LabelizedVariable_label" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = ((gum::LabelizedVariable const *)arg1)->label(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_posLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = (gum::LabelizedVariable *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  if (!SWIG_Python_UnpackTuple(args, "LabelizedVariable_posLabel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LabelizedVariable_posLabel" "', argument " "1"" of type '" "gum::LabelizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LabelizedVariable_posLabel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LabelizedVariable_posLabel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::LabelizedVariable const *)arg1)->posLabel((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_numerical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = (gum::LabelizedVariable *) 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "LabelizedVariable_numerical", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LabelizedVariable_numerical" "', argument " "1"" of type '" "gum::LabelizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LabelizedVariable_numerical" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = (double)((gum::LabelizedVariable const *)arg1)->numerical(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_domainSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = (gum::LabelizedVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LabelizedVariable_domainSize" "', argument " "1"" of type '" "gum::LabelizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  {
    try {
      result = ((gum::LabelizedVariable const *)arg1)->domainSize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_varType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = (gum::LabelizedVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VarType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LabelizedVariable_varType" "', argument " "1"" of type '" "gum::LabelizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  {
    try {
      result = (gum::VarType)((gum::LabelizedVariable const *)arg1)->varType();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable_domain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = (gum::LabelizedVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LabelizedVariable_domain" "', argument " "1"" of type '" "gum::LabelizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  {
    try {
      result = ((gum::LabelizedVariable const *)arg1)->domain();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = (gum::LabelizedVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LabelizedVariable___repr__" "', argument " "1"" of type '" "gum::LabelizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  {
    try {
      result = gum_LabelizedVariable___repr__((gum::LabelizedVariable const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LabelizedVariable___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LabelizedVariable *arg1 = (gum::LabelizedVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LabelizedVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LabelizedVariable___str__" "', argument " "1"" of type '" "gum::LabelizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LabelizedVariable * >(argp1);
  {
    try {
      result = gum_LabelizedVariable___str__((gum::LabelizedVariable const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LabelizedVariable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__LabelizedVariable, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LabelizedVariable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RangeVariable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  long arg3 ;
  long arg4 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  long val3 ;
  int ecode3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  gum::RangeVariable *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RangeVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RangeVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RangeVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RangeVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RangeVariable" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_RangeVariable" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  {
    try {
      result = (gum::RangeVariable *)new gum::RangeVariable((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__RangeVariable, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RangeVariable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  long arg3 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  long val3 ;
  int ecode3 = 0 ;
  gum::RangeVariable *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RangeVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RangeVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RangeVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RangeVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RangeVariable" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      result = (gum::RangeVariable *)new gum::RangeVariable((std::string const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__RangeVariable, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RangeVariable__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  gum::RangeVariable *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RangeVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RangeVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RangeVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RangeVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::RangeVariable *)new gum::RangeVariable((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__RangeVariable, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RangeVariable__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::RangeVariable *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__RangeVariable,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RangeVariable" "', argument " "1"" of type '" "gum::RangeVariable const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RangeVariable" "', argument " "1"" of type '" "gum::RangeVariable const &""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  {
    try {
      result = (gum::RangeVariable *)new gum::RangeVariable((gum::RangeVariable const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__RangeVariable, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RangeVariable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RangeVariable", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__RangeVariable, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RangeVariable__SWIG_3(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RangeVariable__SWIG_2(self, argc, argv);
      }
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_RangeVariable__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(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_RangeVariable__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RangeVariable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::RangeVariable::RangeVariable(std::string const &,std::string const &,long,long)\n"
    "    gum::RangeVariable::RangeVariable(std::string const &,std::string const &,long)\n"
    "    gum::RangeVariable::RangeVariable(std::string const &,std::string const &)\n"
    "    gum::RangeVariable::RangeVariable(gum::RangeVariable const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RangeVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = (gum::RangeVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__RangeVariable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RangeVariable" "', argument " "1"" of type '" "gum::RangeVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = (gum::RangeVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DiscreteVariable *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__RangeVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeVariable_clone" "', argument " "1"" of type '" "gum::RangeVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  {
    try {
      result = (gum::DiscreteVariable *)((gum::RangeVariable const *)arg1)->clone();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_domainSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = (gum::RangeVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__RangeVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeVariable_domainSize" "', argument " "1"" of type '" "gum::RangeVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  {
    try {
      result = ((gum::RangeVariable const *)arg1)->domainSize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_varType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = (gum::RangeVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VarType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__RangeVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeVariable_varType" "', argument " "1"" of type '" "gum::RangeVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  {
    try {
      result = (gum::VarType)((gum::RangeVariable const *)arg1)->varType();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_label(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = (gum::RangeVariable *) 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "RangeVariable_label", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__RangeVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeVariable_label" "', argument " "1"" of type '" "gum::RangeVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RangeVariable_label" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = ((gum::RangeVariable const *)arg1)->label(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_numerical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = (gum::RangeVariable *) 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "RangeVariable_numerical", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__RangeVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeVariable_numerical" "', argument " "1"" of type '" "gum::RangeVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RangeVariable_numerical" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = (double)((gum::RangeVariable const *)arg1)->numerical(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_minVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = (gum::RangeVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__RangeVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeVariable_minVal" "', argument " "1"" of type '" "gum::RangeVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  {
    try {
      result = (long)((gum::RangeVariable const *)arg1)->minVal();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_setMinVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = (gum::RangeVariable *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RangeVariable_setMinVal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__RangeVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeVariable_setMinVal" "', argument " "1"" of type '" "gum::RangeVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RangeVariable_setMinVal" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      (arg1)->setMinVal(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_maxVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = (gum::RangeVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__RangeVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeVariable_maxVal" "', argument " "1"" of type '" "gum::RangeVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  {
    try {
      result = (long)((gum::RangeVariable const *)arg1)->maxVal();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_setMaxVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = (gum::RangeVariable *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RangeVariable_setMaxVal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__RangeVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeVariable_setMaxVal" "', argument " "1"" of type '" "gum::RangeVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RangeVariable_setMaxVal" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      (arg1)->setMaxVal(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_belongs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = (gum::RangeVariable *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "RangeVariable_belongs", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__RangeVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeVariable_belongs" "', argument " "1"" of type '" "gum::RangeVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RangeVariable_belongs" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      result = (bool)((gum::RangeVariable const *)arg1)->belongs(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = (gum::RangeVariable *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  if (!SWIG_Python_UnpackTuple(args, "RangeVariable_index", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__RangeVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeVariable_index" "', argument " "1"" of type '" "gum::RangeVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RangeVariable_index" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RangeVariable_index" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::RangeVariable const *)arg1)->index((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable_domain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = (gum::RangeVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__RangeVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeVariable_domain" "', argument " "1"" of type '" "gum::RangeVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  {
    try {
      result = ((gum::RangeVariable const *)arg1)->domain();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = (gum::RangeVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__RangeVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeVariable___repr__" "', argument " "1"" of type '" "gum::RangeVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  {
    try {
      result = gum_RangeVariable___repr__((gum::RangeVariable const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeVariable___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::RangeVariable *arg1 = (gum::RangeVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__RangeVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeVariable___str__" "', argument " "1"" of type '" "gum::RangeVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::RangeVariable * >(argp1);
  {
    try {
      result = gum_RangeVariable___str__((gum::RangeVariable const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RangeVariable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__RangeVariable, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RangeVariable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_IDiscretizedVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IDiscretizedVariable *arg1 = (gum::IDiscretizedVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IDiscretizedVariable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IDiscretizedVariable" "', argument " "1"" of type '" "gum::IDiscretizedVariable *""'"); 
  }
  arg1 = reinterpret_cast< gum::IDiscretizedVariable * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IDiscretizedVariable_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IDiscretizedVariable *arg1 = (gum::IDiscretizedVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IDiscretizedVariable *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IDiscretizedVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IDiscretizedVariable_clone" "', argument " "1"" of type '" "gum::IDiscretizedVariable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IDiscretizedVariable * >(argp1);
  {
    try {
      result = (gum::IDiscretizedVariable *)((gum::IDiscretizedVariable const *)arg1)->clone();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IDiscretizedVariable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IDiscretizedVariable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__IDiscretizedVariable, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Edge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::NodeId arg1 ;
  gum::NodeId arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Edge *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Edge" "', argument " "1"" of type '" "gum::NodeId""'");
  } 
  arg1 = static_cast< gum::NodeId >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Edge" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Edge *)new gum::Edge(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Edge, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Edge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Edge *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Edge *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__Edge,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Edge" "', argument " "1"" of type '" "gum::Edge const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Edge" "', argument " "1"" of type '" "gum::Edge const &""'"); 
  }
  arg1 = reinterpret_cast< gum::Edge * >(argp1);
  {
    try {
      result = (gum::Edge *)new gum::Edge((gum::Edge const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Edge, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Edge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Edge", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__Edge, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Edge__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Edge__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Edge'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Edge::Edge(gum::NodeId,gum::NodeId)\n"
    "    gum::Edge::Edge(gum::Edge const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Edge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Edge *arg1 = (gum::Edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Edge, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Edge" "', argument " "1"" of type '" "gum::Edge *""'"); 
  }
  arg1 = reinterpret_cast< gum::Edge * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Edge_other(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Edge *arg1 = (gum::Edge *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "Edge_other", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_other" "', argument " "1"" of type '" "gum::Edge const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Edge * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Edge_other" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::Edge const *)arg1)->other(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Edge_first(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Edge *arg1 = (gum::Edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_first" "', argument " "1"" of type '" "gum::Edge const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Edge * >(argp1);
  {
    try {
      result = ((gum::Edge const *)arg1)->first();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Edge_second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Edge *arg1 = (gum::Edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_second" "', argument " "1"" of type '" "gum::Edge const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Edge * >(argp1);
  {
    try {
      result = ((gum::Edge const *)arg1)->second();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Edge___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Edge *arg1 = (gum::Edge *) 0 ;
  gum::Edge *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Edge___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge___eq__" "', argument " "1"" of type '" "gum::Edge const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Edge * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Edge,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge___eq__" "', argument " "2"" of type '" "gum::Edge const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Edge___eq__" "', argument " "2"" of type '" "gum::Edge const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Edge * >(argp2);
  {
    try {
      result = (bool)((gum::Edge const *)arg1)->operator ==((gum::Edge const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Edge___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Edge *arg1 = (gum::Edge *) 0 ;
  gum::Edge *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Edge___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge___ne__" "', argument " "1"" of type '" "gum::Edge const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Edge * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Edge,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge___ne__" "', argument " "2"" of type '" "gum::Edge const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Edge___ne__" "', argument " "2"" of type '" "gum::Edge const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Edge * >(argp2);
  {
    try {
      result = (bool)((gum::Edge const *)arg1)->operator !=((gum::Edge const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *Edge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__Edge, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Edge_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Arc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::NodeId arg1 ;
  gum::NodeId arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Arc *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Arc" "', argument " "1"" of type '" "gum::NodeId""'");
  } 
  arg1 = static_cast< gum::NodeId >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Arc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Arc *)new gum::Arc(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Arc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Arc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Arc *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__Arc,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Arc" "', argument " "1"" of type '" "gum::Arc const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Arc" "', argument " "1"" of type '" "gum::Arc const &""'"); 
  }
  arg1 = reinterpret_cast< gum::Arc * >(argp1);
  {
    try {
      result = (gum::Arc *)new gum::Arc((gum::Arc const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Arc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Arc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Arc", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__Arc, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Arc__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Arc__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Arc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Arc::Arc(gum::NodeId,gum::NodeId)\n"
    "    gum::Arc::Arc(gum::Arc const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Arc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = (gum::Arc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Arc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Arc" "', argument " "1"" of type '" "gum::Arc *""'"); 
  }
  arg1 = reinterpret_cast< gum::Arc * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Arc_tail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = (gum::Arc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Arc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Arc_tail" "', argument " "1"" of type '" "gum::Arc const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Arc * >(argp1);
  {
    try {
      result = ((gum::Arc const *)arg1)->tail();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Arc_head(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = (gum::Arc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Arc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Arc_head" "', argument " "1"" of type '" "gum::Arc const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Arc * >(argp1);
  {
    try {
      result = ((gum::Arc const *)arg1)->head();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Arc_other(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = (gum::Arc *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "Arc_other", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Arc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Arc_other" "', argument " "1"" of type '" "gum::Arc const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Arc * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Arc_other" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::Arc const *)arg1)->other(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Arc_first(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = (gum::Arc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Arc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Arc_first" "', argument " "1"" of type '" "gum::Arc const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Arc * >(argp1);
  {
    try {
      result = ((gum::Arc const *)arg1)->first();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Arc_second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = (gum::Arc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Arc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Arc_second" "', argument " "1"" of type '" "gum::Arc const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Arc * >(argp1);
  {
    try {
      result = ((gum::Arc const *)arg1)->second();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Arc___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = (gum::Arc *) 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Arc___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Arc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Arc___eq__" "', argument " "1"" of type '" "gum::Arc const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Arc * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Arc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Arc___eq__" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Arc___eq__" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Arc * >(argp2);
  {
    try {
      result = (bool)((gum::Arc const *)arg1)->operator ==((gum::Arc const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Arc___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Arc *arg1 = (gum::Arc *) 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Arc___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Arc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Arc___ne__" "', argument " "1"" of type '" "gum::Arc const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Arc * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Arc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Arc___ne__" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Arc___ne__" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Arc * >(argp2);
  {
    try {
      result = (bool)((gum::Arc const *)arg1)->operator !=((gum::Arc const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *Arc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__Arc, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Arc_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UndiGraph__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  gum::Size arg3 ;
  bool arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  gum::UndiGraph *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UndiGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UndiGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UndiGraph" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UndiGraph" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (gum::UndiGraph *)new gum::UndiGraph(arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndiGraph__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  gum::Size arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::UndiGraph *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UndiGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UndiGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UndiGraph" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  {
    try {
      result = (gum::UndiGraph *)new gum::UndiGraph(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndiGraph__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  gum::UndiGraph *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UndiGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UndiGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::UndiGraph *)new gum::UndiGraph(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndiGraph__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  gum::UndiGraph *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UndiGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  {
    try {
      result = (gum::UndiGraph *)new gum::UndiGraph(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndiGraph__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::UndiGraph *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (gum::UndiGraph *)new gum::UndiGraph();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndiGraph__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::UndiGraph *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__UndiGraph,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UndiGraph" "', argument " "1"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UndiGraph" "', argument " "1"" of type '" "gum::UndiGraph const &""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = (gum::UndiGraph *)new gum::UndiGraph((gum::UndiGraph const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndiGraph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UndiGraph", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_UndiGraph__SWIG_4(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UndiGraph__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UndiGraph__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_new_UndiGraph__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UndiGraph__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_AsVal_size_t(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_new_UndiGraph__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UndiGraph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::UndiGraph::UndiGraph(gum::Size,bool,gum::Size,bool)\n"
    "    gum::UndiGraph::UndiGraph(gum::Size,bool,gum::Size)\n"
    "    gum::UndiGraph::UndiGraph(gum::Size,bool)\n"
    "    gum::UndiGraph::UndiGraph(gum::Size)\n"
    "    gum::UndiGraph::UndiGraph()\n"
    "    gum::UndiGraph::UndiGraph(gum::UndiGraph const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UndiGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UndiGraph" "', argument " "1"" of type '" "gum::UndiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  gum::UndiGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph___eq__" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__UndiGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UndiGraph___eq__" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UndiGraph___eq__" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::UndiGraph * >(argp2);
  {
    try {
      result = (bool)((gum::UndiGraph const *)arg1)->operator ==((gum::UndiGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_UndiGraph___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  gum::UndiGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph___ne__" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__UndiGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UndiGraph___ne__" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UndiGraph___ne__" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::UndiGraph * >(argp2);
  {
    try {
      result = (bool)((gum::UndiGraph const *)arg1)->operator !=((gum::UndiGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_UndiGraph_eraseNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph_eraseNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_eraseNode" "', argument " "1"" of type '" "gum::UndiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UndiGraph_eraseNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      (arg1)->eraseNode(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_clear" "', argument " "1"" of type '" "gum::UndiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_toDot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_toDot" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = ((gum::UndiGraph const *)arg1)->toDot();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_hasUndirectedCycle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_hasUndirectedCycle" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = (bool)((gum::UndiGraph const *)arg1)->hasUndirectedCycle();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_partialUndiGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  SwigValueWrapper< gum::Set< std::size_t > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::UndiGraph result;
  
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph_partialUndiGraph", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_partialUndiGraph" "', argument " "1"" of type '" "gum::UndiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UndiGraph_partialUndiGraph" "', argument " "2"" of type '" "gum::NodeSet""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UndiGraph_partialUndiGraph" "', argument " "2"" of type '" "gum::NodeSet""'");
    } else {
      gum::NodeSet * temp = reinterpret_cast< gum::NodeSet * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (arg1)->partialUndiGraph(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(static_cast< const gum::UndiGraph& >(result))), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph___repr__" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = gum_UndiGraph___repr__((gum::UndiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph___str__" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = gum_UndiGraph___str__((gum::UndiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_nodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_nodes" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = (PyObject *)gum_UndiGraph_nodes((gum::UndiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_addNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph_addNodes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_addNodes" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UndiGraph_addNodes" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = (PyObject *)gum_UndiGraph_addNodes((gum::UndiGraph const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_edges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_edges" "', argument " "1"" of type '" "gum::UndiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = (PyObject *)gum_UndiGraph_edges(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_neighbours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph_neighbours", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_neighbours" "', argument " "1"" of type '" "gum::UndiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UndiGraph_neighbours" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_UndiGraph_neighbours(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_addNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_addNode" "', argument " "1"" of type '" "gum::UndiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = gum_UndiGraph_addNode(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_addNodeWithId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph_addNodeWithId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_addNodeWithId" "', argument " "1"" of type '" "gum::UndiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UndiGraph_addNodeWithId" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_UndiGraph_addNodeWithId(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_existsNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph_existsNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_existsNode" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UndiGraph_existsNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_UndiGraph_existsNode((gum::UndiGraph const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_size" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = gum_UndiGraph_size((gum::UndiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_empty" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = (bool)gum_UndiGraph_empty((gum::UndiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_addEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph_addEdge", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_addEdge" "', argument " "1"" of type '" "gum::UndiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UndiGraph_addEdge" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UndiGraph_addEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_UndiGraph_addEdge(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_eraseEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph_eraseEdge", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_eraseEdge" "', argument " "1"" of type '" "gum::UndiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UndiGraph_eraseEdge" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UndiGraph_eraseEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_UndiGraph_eraseEdge(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_existsEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph_existsEdge", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_existsEdge" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UndiGraph_existsEdge" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UndiGraph_existsEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)gum_UndiGraph_existsEdge((gum::UndiGraph const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_sizeEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_sizeEdges" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = gum_UndiGraph_sizeEdges((gum::UndiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_emptyEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_emptyEdges" "', argument " "1"" of type '" "gum::UndiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  {
    try {
      result = (bool)gum_UndiGraph_emptyEdges((gum::UndiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UndiGraph_eraseNeighbours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::UndiGraph *arg1 = (gum::UndiGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UndiGraph_eraseNeighbours", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UndiGraph_eraseNeighbours" "', argument " "1"" of type '" "gum::UndiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::UndiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UndiGraph_eraseNeighbours" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_UndiGraph_eraseNeighbours(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UndiGraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__UndiGraph, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UndiGraph_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DiGraph__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  gum::Size arg3 ;
  bool arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  gum::DiGraph *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DiGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DiGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DiGraph" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DiGraph" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (gum::DiGraph *)new gum::DiGraph(arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiGraph__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  gum::Size arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::DiGraph *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DiGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DiGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DiGraph" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  {
    try {
      result = (gum::DiGraph *)new gum::DiGraph(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiGraph__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  gum::DiGraph *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DiGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DiGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::DiGraph *)new gum::DiGraph(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiGraph__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  gum::DiGraph *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DiGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  {
    try {
      result = (gum::DiGraph *)new gum::DiGraph(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiGraph__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::DiGraph *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (gum::DiGraph *)new gum::DiGraph();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiGraph__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::DiGraph *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__DiGraph,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiGraph" "', argument " "1"" of type '" "gum::DiGraph const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiGraph" "', argument " "1"" of type '" "gum::DiGraph const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = (gum::DiGraph *)new gum::DiGraph((gum::DiGraph const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiGraph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DiGraph", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DiGraph__SWIG_4(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiGraph__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DiGraph__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_new_DiGraph__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_DiGraph__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_AsVal_size_t(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_new_DiGraph__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DiGraph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DiGraph::DiGraph(gum::Size,bool,gum::Size,bool)\n"
    "    gum::DiGraph::DiGraph(gum::Size,bool,gum::Size)\n"
    "    gum::DiGraph::DiGraph(gum::Size,bool)\n"
    "    gum::DiGraph::DiGraph(gum::Size)\n"
    "    gum::DiGraph::DiGraph()\n"
    "    gum::DiGraph::DiGraph(gum::DiGraph const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DiGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiGraph" "', argument " "1"" of type '" "gum::DiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  gum::DiGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "DiGraph___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph___eq__" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiGraph___eq__" "', argument " "2"" of type '" "gum::DiGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiGraph___eq__" "', argument " "2"" of type '" "gum::DiGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiGraph * >(argp2);
  {
    try {
      result = (bool)((gum::DiGraph const *)arg1)->operator ==((gum::DiGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_DiGraph___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  gum::DiGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "DiGraph___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph___ne__" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiGraph___ne__" "', argument " "2"" of type '" "gum::DiGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiGraph___ne__" "', argument " "2"" of type '" "gum::DiGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiGraph * >(argp2);
  {
    try {
      result = (bool)((gum::DiGraph const *)arg1)->operator !=((gum::DiGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_DiGraph_addArc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_addArc" "', argument " "1"" of type '" "gum::DiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiGraph_addArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DiGraph_addArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->addArc(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_eraseNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_eraseNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_eraseNode" "', argument " "1"" of type '" "gum::DiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiGraph_eraseNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      (arg1)->eraseNode(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_clear" "', argument " "1"" of type '" "gum::DiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_toDot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_toDot" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = ((gum::DiGraph const *)arg1)->toDot();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_topologicalOrder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  gum::Sequence< gum::NodeId > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_topologicalOrder" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiGraph_topologicalOrder" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::Sequence< gum::NodeId > *) &((gum::DiGraph const *)arg1)->topologicalOrder(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    PyObject *q=PyList_New(0);
    for(auto i : *result) {
      PyList_Append(q,PyInt_FromLong(i));
    }
    resultobj=q;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_topologicalOrder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Sequence< gum::NodeId > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_topologicalOrder" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = (gum::Sequence< gum::NodeId > *) &((gum::DiGraph const *)arg1)->topologicalOrder();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    PyObject *q=PyList_New(0);
    for(auto i : *result) {
      PyList_Append(q,PyInt_FromLong(i));
    }
    resultobj=q;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_topologicalOrder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DiGraph_topologicalOrder", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DiGraph, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DiGraph_topologicalOrder__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DiGraph, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DiGraph_topologicalOrder__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiGraph_topologicalOrder'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DiGraph::topologicalOrder(bool) const\n"
    "    gum::DiGraph::topologicalOrder() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DiGraph___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph___repr__" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = gum_DiGraph___repr__((gum::DiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph___str__" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = gum_DiGraph___str__((gum::DiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_nodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_nodes" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = (PyObject *)gum_DiGraph_nodes((gum::DiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_addNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_addNodes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_addNodes" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiGraph_addNodes" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = (PyObject *)gum_DiGraph_addNodes((gum::DiGraph const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_arcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_arcs" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = (PyObject *)gum_DiGraph_arcs((gum::DiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_parents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_parents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_parents" "', argument " "1"" of type '" "gum::DiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiGraph_parents" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_DiGraph_parents(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_children(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_children", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_children" "', argument " "1"" of type '" "gum::DiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiGraph_children" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_DiGraph_children(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_addNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeId result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_addNode" "', argument " "1"" of type '" "gum::DiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = gum_DiGraph_addNode(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_addNodeWithId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_addNodeWithId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_addNodeWithId" "', argument " "1"" of type '" "gum::DiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiGraph_addNodeWithId" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_DiGraph_addNodeWithId(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_existsNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_existsNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_existsNode" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiGraph_existsNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_DiGraph_existsNode((gum::DiGraph const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_size" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = gum_DiGraph_size((gum::DiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_empty" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = (bool)gum_DiGraph_empty((gum::DiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_addArc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_addArc" "', argument " "1"" of type '" "gum::DiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiGraph_addArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DiGraph_addArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_DiGraph_addArc__SWIG_1(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_addArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DiGraph_addArc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DiGraph, 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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DiGraph_addArc__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DiGraph, 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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DiGraph_addArc__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiGraph_addArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DiGraph::addArc(gum::NodeId const,gum::NodeId const)\n"
    "    gum::DiGraph::addArc(gum::NodeId const,gum::NodeId const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DiGraph_eraseArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_eraseArc", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_eraseArc" "', argument " "1"" of type '" "gum::DiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiGraph_eraseArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DiGraph_eraseArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_DiGraph_eraseArc(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_existsArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_existsArc", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_existsArc" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiGraph_existsArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DiGraph_existsArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)gum_DiGraph_existsArc((gum::DiGraph const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_eraseParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_eraseParents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_eraseParents" "', argument " "1"" of type '" "gum::DiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiGraph_eraseParents" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_DiGraph_eraseParents(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_eraseChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DiGraph_eraseChildren", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_eraseChildren" "', argument " "1"" of type '" "gum::DiGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiGraph_eraseChildren" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_DiGraph_eraseChildren(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_sizeArcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_sizeArcs" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = gum_DiGraph_sizeArcs((gum::DiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiGraph_emptyArcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiGraph *arg1 = (gum::DiGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiGraph_emptyArcs" "', argument " "1"" of type '" "gum::DiGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiGraph * >(argp1);
  {
    try {
      result = (bool)gum_DiGraph_emptyArcs((gum::DiGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DiGraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__DiGraph, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DiGraph_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DAG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  gum::Size arg3 ;
  bool arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  gum::DAG *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DAG" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DAG" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DAG" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DAG" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (gum::DAG *)new gum::DAG(arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DAG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  gum::Size arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::DAG *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DAG" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DAG" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DAG" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  {
    try {
      result = (gum::DAG *)new gum::DAG(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DAG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  gum::DAG *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DAG" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DAG" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::DAG *)new gum::DAG(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DAG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  gum::DAG *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DAG" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  {
    try {
      result = (gum::DAG *)new gum::DAG(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DAG__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::DAG *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (gum::DAG *)new gum::DAG();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DAG__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::DAG *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__DAG,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DAG" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DAG" "', argument " "1"" of type '" "gum::DAG const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  {
    try {
      result = (gum::DAG *)new gum::DAG((gum::DAG const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DAG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DAG(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DAG", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DAG__SWIG_4(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DAG__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DAG__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_new_DAG__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_DAG__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_AsVal_size_t(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_new_DAG__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DAG'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAG::DAG(gum::Size,bool,gum::Size,bool)\n"
    "    gum::DAG::DAG(gum::Size,bool,gum::Size)\n"
    "    gum::DAG::DAG(gum::Size,bool)\n"
    "    gum::DAG::DAG(gum::Size)\n"
    "    gum::DAG::DAG()\n"
    "    gum::DAG::DAG(gum::DAG const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DAG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = (gum::DAG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAG, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DAG" "', argument " "1"" of type '" "gum::DAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_addArc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = (gum::DAG *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAG_addArc" "', argument " "1"" of type '" "gum::DAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DAG_addArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DAG_addArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->addArc(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_moralGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = (gum::DAG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::UndiGraph result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAG_moralGraph" "', argument " "1"" of type '" "gum::DAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  {
    try {
      result = ((gum::DAG const *)arg1)->moralGraph();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::UndiGraph(static_cast< const gum::UndiGraph& >(result))), SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_addNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = (gum::DAG *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DAG_addNodes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAG_addNodes" "', argument " "1"" of type '" "gum::DAG const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DAG_addNodes" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = (PyObject *)gum_DAG_addNodes((gum::DAG const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_addArc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAG *arg1 = (gum::DAG *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAG_addArc" "', argument " "1"" of type '" "gum::DAG *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAG * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DAG_addArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DAG_addArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_DAG_addArc__SWIG_1(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAG_addArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAG_addArc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DAG, 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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DAG_addArc__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DAG, 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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DAG_addArc__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAG_addArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAG::addArc(gum::NodeId const,gum::NodeId const)\n"
    "    gum::DAG::addArc(gum::NodeId const,gum::NodeId const)\n");
  return 0;
}


SWIGINTERN PyObject *DAG_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__DAG, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DAG_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MixedGraph__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  gum::Size arg3 ;
  bool arg4 ;
  gum::Size arg5 ;
  bool arg6 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  gum::MixedGraph *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MixedGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MixedGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MixedGraph" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MixedGraph" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MixedGraph" "', argument " "5"" of type '" "gum::Size""'");
  } 
  arg5 = static_cast< gum::Size >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MixedGraph" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (gum::MixedGraph *)new gum::MixedGraph(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MixedGraph__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  gum::Size arg3 ;
  bool arg4 ;
  gum::Size arg5 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  gum::MixedGraph *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MixedGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MixedGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MixedGraph" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MixedGraph" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MixedGraph" "', argument " "5"" of type '" "gum::Size""'");
  } 
  arg5 = static_cast< gum::Size >(val5);
  {
    try {
      result = (gum::MixedGraph *)new gum::MixedGraph(arg1,arg2,arg3,arg4,arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MixedGraph__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  gum::Size arg3 ;
  bool arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  gum::MixedGraph *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MixedGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MixedGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MixedGraph" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MixedGraph" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (gum::MixedGraph *)new gum::MixedGraph(arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MixedGraph__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  gum::Size arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::MixedGraph *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MixedGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MixedGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MixedGraph" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  {
    try {
      result = (gum::MixedGraph *)new gum::MixedGraph(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MixedGraph__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  gum::MixedGraph *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MixedGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MixedGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::MixedGraph *)new gum::MixedGraph(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MixedGraph__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  gum::MixedGraph *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MixedGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  {
    try {
      result = (gum::MixedGraph *)new gum::MixedGraph(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MixedGraph__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::MixedGraph *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (gum::MixedGraph *)new gum::MixedGraph();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MixedGraph__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::MixedGraph *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__MixedGraph,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedGraph" "', argument " "1"" of type '" "gum::MixedGraph const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedGraph" "', argument " "1"" of type '" "gum::MixedGraph const &""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = (gum::MixedGraph *)new gum::MixedGraph((gum::MixedGraph const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MixedGraph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedGraph", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MixedGraph__SWIG_6(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MixedGraph__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_MixedGraph__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_new_MixedGraph__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_MixedGraph__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_AsVal_size_t(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_new_MixedGraph__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_AsVal_size_t(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_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_MixedGraph__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_AsVal_size_t(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_size_t(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_new_MixedGraph__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedGraph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MixedGraph::MixedGraph(gum::Size,bool,gum::Size,bool,gum::Size,bool)\n"
    "    gum::MixedGraph::MixedGraph(gum::Size,bool,gum::Size,bool,gum::Size)\n"
    "    gum::MixedGraph::MixedGraph(gum::Size,bool,gum::Size,bool)\n"
    "    gum::MixedGraph::MixedGraph(gum::Size,bool,gum::Size)\n"
    "    gum::MixedGraph::MixedGraph(gum::Size,bool)\n"
    "    gum::MixedGraph::MixedGraph(gum::Size)\n"
    "    gum::MixedGraph::MixedGraph()\n"
    "    gum::MixedGraph::MixedGraph(gum::MixedGraph const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MixedGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = (gum::MixedGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedGraph" "', argument " "1"" of type '" "gum::MixedGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = (gum::MixedGraph *) 0 ;
  gum::MixedGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MixedGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGraph___eq__" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__MixedGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGraph___eq__" "', argument " "2"" of type '" "gum::MixedGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGraph___eq__" "', argument " "2"" of type '" "gum::MixedGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MixedGraph * >(argp2);
  {
    try {
      result = (bool)((gum::MixedGraph const *)arg1)->operator ==((gum::MixedGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_MixedGraph___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = (gum::MixedGraph *) 0 ;
  gum::MixedGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MixedGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGraph___ne__" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__MixedGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGraph___ne__" "', argument " "2"" of type '" "gum::MixedGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGraph___ne__" "', argument " "2"" of type '" "gum::MixedGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MixedGraph * >(argp2);
  {
    try {
      result = (bool)((gum::MixedGraph const *)arg1)->operator !=((gum::MixedGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_MixedGraph_eraseNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = (gum::MixedGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_eraseNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MixedGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGraph_eraseNode" "', argument " "1"" of type '" "gum::MixedGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MixedGraph_eraseNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      (arg1)->eraseNode(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = (gum::MixedGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MixedGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGraph_clear" "', argument " "1"" of type '" "gum::MixedGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_mixedOrientedPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = (gum::MixedGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SwigValueWrapper< std::vector< std::size_t,std::allocator< std::size_t > > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_mixedOrientedPath", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MixedGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGraph_mixedOrientedPath" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MixedGraph_mixedOrientedPath" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MixedGraph_mixedOrientedPath" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = ((gum::MixedGraph const *)arg1)->mixedOrientedPath(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< gum::NodeId,std::allocator< gum::NodeId > >(static_cast< const std::vector< gum::NodeId,std::allocator< gum::NodeId > >& >(result))), SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_mixedUnorientedPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = (gum::MixedGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SwigValueWrapper< std::vector< std::size_t,std::allocator< std::size_t > > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "MixedGraph_mixedUnorientedPath", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MixedGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGraph_mixedUnorientedPath" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MixedGraph_mixedUnorientedPath" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MixedGraph_mixedUnorientedPath" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = ((gum::MixedGraph const *)arg1)->mixedUnorientedPath(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< gum::NodeId,std::allocator< gum::NodeId > >(static_cast< const std::vector< gum::NodeId,std::allocator< gum::NodeId > >& >(result))), SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph_toDot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = (gum::MixedGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MixedGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGraph_toDot" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = ((gum::MixedGraph const *)arg1)->toDot();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = (gum::MixedGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MixedGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGraph___repr__" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = gum_MixedGraph___repr__((gum::MixedGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MixedGraph___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MixedGraph *arg1 = (gum::MixedGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MixedGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGraph___str__" "', argument " "1"" of type '" "gum::MixedGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MixedGraph * >(argp1);
  {
    try {
      result = gum_MixedGraph___str__((gum::MixedGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MixedGraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__MixedGraph, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MixedGraph_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CliqueGraph__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  gum::Size arg3 ;
  bool arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  gum::CliqueGraph *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CliqueGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CliqueGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CliqueGraph" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CliqueGraph" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (gum::CliqueGraph *)new gum::CliqueGraph(arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CliqueGraph__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  gum::Size arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::CliqueGraph *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CliqueGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CliqueGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CliqueGraph" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  {
    try {
      result = (gum::CliqueGraph *)new gum::CliqueGraph(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CliqueGraph__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  bool arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  gum::CliqueGraph *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CliqueGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CliqueGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::CliqueGraph *)new gum::CliqueGraph(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CliqueGraph__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  gum::CliqueGraph *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CliqueGraph" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  {
    try {
      result = (gum::CliqueGraph *)new gum::CliqueGraph(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CliqueGraph__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (gum::CliqueGraph *)new gum::CliqueGraph();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CliqueGraph__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::CliqueGraph *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__CliqueGraph,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CliqueGraph" "', argument " "1"" of type '" "gum::CliqueGraph const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CliqueGraph" "', argument " "1"" of type '" "gum::CliqueGraph const &""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  {
    try {
      result = (gum::CliqueGraph *)new gum::CliqueGraph((gum::CliqueGraph const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CliqueGraph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CliqueGraph", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CliqueGraph__SWIG_4(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CliqueGraph__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CliqueGraph__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_new_CliqueGraph__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_CliqueGraph__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_AsVal_size_t(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_new_CliqueGraph__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CliqueGraph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CliqueGraph::CliqueGraph(gum::Size,bool,gum::Size,bool)\n"
    "    gum::CliqueGraph::CliqueGraph(gum::Size,bool,gum::Size)\n"
    "    gum::CliqueGraph::CliqueGraph(gum::Size,bool)\n"
    "    gum::CliqueGraph::CliqueGraph(gum::Size)\n"
    "    gum::CliqueGraph::CliqueGraph()\n"
    "    gum::CliqueGraph::CliqueGraph(gum::CliqueGraph const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CliqueGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CliqueGraph" "', argument " "1"" of type '" "gum::CliqueGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_addEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CliqueGraph_addEdge", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_addEdge" "', argument " "1"" of type '" "gum::CliqueGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CliqueGraph_addEdge" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CliqueGraph_addEdge" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->addEdge(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_eraseEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  gum::Edge *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CliqueGraph_eraseEdge", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_eraseEdge" "', argument " "1"" of type '" "gum::CliqueGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Edge,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CliqueGraph_eraseEdge" "', argument " "2"" of type '" "gum::Edge const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CliqueGraph_eraseEdge" "', argument " "2"" of type '" "gum::Edge const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Edge * >(argp2);
  {
    try {
      (arg1)->eraseEdge((gum::Edge const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_clearEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_clearEdges" "', argument " "1"" of type '" "gum::CliqueGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  {
    try {
      (arg1)->clearEdges();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_addNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  gum::NodeSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_addNode" "', argument " "1"" of type '" "gum::CliqueGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CliqueGraph_addNode" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CliqueGraph_addNode" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::NodeSet * >(argp2);
  {
    try {
      result = (arg1)->addNode((gum::NodeSet const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_addNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_addNode" "', argument " "1"" of type '" "gum::CliqueGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  {
    try {
      result = (arg1)->addNode();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_addNode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeSet *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_addNode" "', argument " "1"" of type '" "gum::CliqueGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CliqueGraph_addNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CliqueGraph_addNode" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CliqueGraph_addNode" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      (arg1)->addNode(arg2,(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_addNode__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_addNode" "', argument " "1"" of type '" "gum::CliqueGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CliqueGraph_addNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      (arg1)->addNode(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_addNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CliqueGraph_addNode", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__CliqueGraph, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CliqueGraph_addNode__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__CliqueGraph, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CliqueGraph_addNode__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__CliqueGraph, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CliqueGraph_addNode__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__CliqueGraph, 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_gum__SetT_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CliqueGraph_addNode__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CliqueGraph_addNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::CliqueGraph::addNode(gum::NodeSet const &)\n"
    "    gum::CliqueGraph::addNode()\n"
    "    gum::CliqueGraph::addNode(gum::NodeId const,gum::NodeSet const &)\n"
    "    gum::CliqueGraph::addNode(gum::NodeId const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_eraseNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CliqueGraph_eraseNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_eraseNode" "', argument " "1"" of type '" "gum::CliqueGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CliqueGraph_eraseNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      (arg1)->eraseNode(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_clear" "', argument " "1"" of type '" "gum::CliqueGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_container(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "CliqueGraph_container", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_container" "', argument " "1"" of type '" "gum::CliqueGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CliqueGraph_container" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = ((gum::CliqueGraph const *)arg1)->container(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_setClique(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeSet *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CliqueGraph_setClique", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_setClique" "', argument " "1"" of type '" "gum::CliqueGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CliqueGraph_setClique" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CliqueGraph_setClique" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CliqueGraph_setClique" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      (arg1)->setClique(arg2,(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_addToClique(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CliqueGraph_addToClique", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_addToClique" "', argument " "1"" of type '" "gum::CliqueGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CliqueGraph_addToClique" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CliqueGraph_addToClique" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->addToClique(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_eraseFromClique(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CliqueGraph_eraseFromClique", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_eraseFromClique" "', argument " "1"" of type '" "gum::CliqueGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CliqueGraph_eraseFromClique" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CliqueGraph_eraseFromClique" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->eraseFromClique(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_containerPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SwigValueWrapper< std::vector< std::size_t,std::allocator< std::size_t > > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "CliqueGraph_containerPath", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_containerPath" "', argument " "1"" of type '" "gum::CliqueGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CliqueGraph_containerPath" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CliqueGraph_containerPath" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = ((gum::CliqueGraph const *)arg1)->containerPath(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< gum::NodeId,std::allocator< gum::NodeId > >(static_cast< const std::vector< gum::NodeId,std::allocator< gum::NodeId > >& >(result))), SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_hasRunningIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_hasRunningIntersection" "', argument " "1"" of type '" "gum::CliqueGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  {
    try {
      result = (bool)((gum::CliqueGraph const *)arg1)->hasRunningIntersection();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_isJoinTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_isJoinTree" "', argument " "1"" of type '" "gum::CliqueGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  {
    try {
      result = (bool)((gum::CliqueGraph const *)arg1)->isJoinTree();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_toDot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_toDot" "', argument " "1"" of type '" "gum::CliqueGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  {
    try {
      result = ((gum::CliqueGraph const *)arg1)->toDot();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  gum::CliqueGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "CliqueGraph___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph___ne__" "', argument " "1"" of type '" "gum::CliqueGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__CliqueGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CliqueGraph___ne__" "', argument " "2"" of type '" "gum::CliqueGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CliqueGraph___ne__" "', argument " "2"" of type '" "gum::CliqueGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::CliqueGraph * >(argp2);
  {
    try {
      result = (bool)((gum::CliqueGraph const *)arg1)->operator !=((gum::CliqueGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_CliqueGraph___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  gum::CliqueGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "CliqueGraph___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph___eq__" "', argument " "1"" of type '" "gum::CliqueGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__CliqueGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CliqueGraph___eq__" "', argument " "2"" of type '" "gum::CliqueGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CliqueGraph___eq__" "', argument " "2"" of type '" "gum::CliqueGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::CliqueGraph * >(argp2);
  {
    try {
      result = (bool)((gum::CliqueGraph const *)arg1)->operator ==((gum::CliqueGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_clique(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "CliqueGraph_clique", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_clique" "', argument " "1"" of type '" "gum::CliqueGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CliqueGraph_clique" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_CliqueGraph_clique((gum::CliqueGraph const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CliqueGraph_separator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::CliqueGraph *arg1 = (gum::CliqueGraph *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "CliqueGraph_separator", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CliqueGraph_separator" "', argument " "1"" of type '" "gum::CliqueGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::CliqueGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CliqueGraph_separator" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CliqueGraph_separator" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (PyObject *)gum_CliqueGraph_separator((gum::CliqueGraph const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CliqueGraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__CliqueGraph, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CliqueGraph_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Instantiation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::Instantiation *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (gum::Instantiation *)new gum::Instantiation();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Instantiation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  gum::Instantiation *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Instantiation" "', argument " "1"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Instantiation" "', argument " "1"" of type '" "gum::Instantiation const &""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Instantiation" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::Instantiation *)new gum::Instantiation((gum::Instantiation const &)*arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Instantiation__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Instantiation *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Instantiation" "', argument " "1"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Instantiation" "', argument " "1"" of type '" "gum::Instantiation const &""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      result = (gum::Instantiation *)new gum::Instantiation((gum::Instantiation const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Instantiation__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimAdressable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Instantiation *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__MultiDimAdressable,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Instantiation" "', argument " "1"" of type '" "gum::MultiDimAdressable &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Instantiation" "', argument " "1"" of type '" "gum::MultiDimAdressable &""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimAdressable * >(argp1);
  {
    try {
      result = (gum::Instantiation *)new gum::Instantiation(*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Instantiation__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimAdressable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Instantiation *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__MultiDimAdressable,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Instantiation" "', argument " "1"" of type '" "gum::MultiDimAdressable const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Instantiation" "', argument " "1"" of type '" "gum::MultiDimAdressable const &""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimAdressable * >(argp1);
  {
    try {
      result = (gum::Instantiation *)new gum::Instantiation((gum::MultiDimAdressable const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Instantiation__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimAdressable *arg1 = (gum::MultiDimAdressable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Instantiation *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimAdressable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Instantiation" "', argument " "1"" of type '" "gum::MultiDimAdressable *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimAdressable * >(argp1);
  {
    try {
      result = (gum::Instantiation *)new gum::Instantiation(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Instantiation__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimAdressable *arg1 = (gum::MultiDimAdressable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Instantiation *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimAdressable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Instantiation" "', argument " "1"" of type '" "gum::MultiDimAdressable const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimAdressable * >(argp1);
  {
    try {
      result = (gum::Instantiation *)new gum::Instantiation((gum::MultiDimAdressable const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Instantiation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Instantiation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Instantiation__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Instantiation__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimAdressable, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Instantiation__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__MultiDimAdressable, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Instantiation__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimAdressable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Instantiation__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimAdressable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Instantiation__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Instantiation__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Instantiation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Instantiation::Instantiation()\n"
    "    gum::Instantiation::Instantiation(gum::Instantiation const &,bool const)\n"
    "    gum::Instantiation::Instantiation(gum::Instantiation const &)\n"
    "    gum::Instantiation::Instantiation(gum::MultiDimAdressable &)\n"
    "    gum::Instantiation::Instantiation(gum::MultiDimAdressable const &)\n"
    "    gum::Instantiation::Instantiation(gum::MultiDimAdressable *)\n"
    "    gum::Instantiation::Instantiation(gum::MultiDimAdressable const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Instantiation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Instantiation" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_nbrDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Idx result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_nbrDim" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      result = ((gum::Instantiation const *)arg1)->nbrDim();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_add" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      (arg1)->add((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_erase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_erase", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_erase" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_erase" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_erase" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      (arg1)->erase((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_clear" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_domainSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_domainSize" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      result = ((gum::Instantiation const *)arg1)->domainSize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_pos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_pos", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_pos" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_pos" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_pos" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = ((gum::Instantiation const *)arg1)->pos((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_val__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Idx result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_val" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Instantiation_val" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = ((gum::Instantiation const *)arg1)->val(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_val__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Idx result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_val" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_val" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_val" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = ((gum::Instantiation const *)arg1)->val((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_val(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Instantiation_val", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__Instantiation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Instantiation_val__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__Instantiation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Instantiation_val__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Instantiation_val'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Instantiation::val(gum::Idx) const\n"
    "    gum::Instantiation::val(gum::DiscreteVariable const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Instantiation_variable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::DiscreteVariable *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_variable" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Instantiation_variable" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::Instantiation const *)arg1)->variable(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_variable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::DiscreteVariable *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_variable" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_variable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_variable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::Instantiation const *)arg1)->variable((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_variable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Instantiation_variable", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__Instantiation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Instantiation_variable__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__Instantiation, 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_Instantiation_variable__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Instantiation_variable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Instantiation::variable(gum::Idx) const\n"
    "    gum::Instantiation::variable(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Instantiation_chgVal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::Instantiation *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_chgVal" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_chgVal" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_chgVal" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Instantiation_chgVal" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      result = (gum::Instantiation *) &(arg1)->chgVal((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_chgVal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = (gum::DiscreteVariable *) 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::Instantiation *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_chgVal" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_chgVal" "', argument " "2"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Instantiation_chgVal" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      result = (gum::Instantiation *) &(arg1)->chgVal((gum::DiscreteVariable const *)arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_chgVal__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Idx arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::Instantiation *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_chgVal" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Instantiation_chgVal" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Instantiation_chgVal" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      result = (gum::Instantiation *) &(arg1)->chgVal(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_chgVal__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::Instantiation *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_chgVal" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_chgVal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_chgVal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Instantiation_chgVal" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      result = (gum::Instantiation *) &(arg1)->chgVal((std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_chgVal__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::Instantiation *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_chgVal" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_chgVal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_chgVal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Instantiation_chgVal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_chgVal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (gum::Instantiation *) &(arg1)->chgVal((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_chgVal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Instantiation_chgVal", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__Instantiation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Instantiation_chgVal__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__Instantiation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_gum__DiscreteVariable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Instantiation_chgVal__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__Instantiation, 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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Instantiation_chgVal__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__Instantiation, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Instantiation_chgVal__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__Instantiation, 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_Instantiation_chgVal__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Instantiation_chgVal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Instantiation::chgVal(gum::DiscreteVariable const &,gum::Idx)\n"
    "    gum::Instantiation::chgVal(gum::DiscreteVariable const *,gum::Idx)\n"
    "    gum::Instantiation::chgVal(gum::Idx,gum::Idx)\n"
    "    gum::Instantiation::chgVal(std::string const &,gum::Idx)\n"
    "    gum::Instantiation::chgVal(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Instantiation_setVals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Instantiation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_setVals", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_setVals" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_setVals" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_setVals" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      result = (gum::Instantiation *) &(arg1)->setVals((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_contains__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_contains" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_contains" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_contains" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (bool)((gum::Instantiation const *)arg1)->contains((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_contains__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = (gum::DiscreteVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_contains" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_contains" "', argument " "2"" of type '" "gum::DiscreteVariable const *""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (bool)((gum::Instantiation const *)arg1)->contains((gum::DiscreteVariable const *)arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_contains(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Instantiation_contains", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__Instantiation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Instantiation_contains__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__Instantiation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_gum__DiscreteVariable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Instantiation_contains__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Instantiation_contains'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Instantiation::contains(gum::DiscreteVariable const &) const\n"
    "    gum::Instantiation::contains(gum::DiscreteVariable const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Instantiation_variablesSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Sequence< gum::DiscreteVariable const * > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_variablesSequence" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      result = (gum::Sequence< gum::DiscreteVariable const * > *) &((gum::Instantiation const *)arg1)->variablesSequence();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SequenceT_gum__DiscreteVariable_const_p_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_empty" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      result = (bool)((gum::Instantiation const *)arg1)->empty();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_inOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_inOverflow" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      result = (bool)((gum::Instantiation const *)arg1)->inOverflow();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_unsetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_unsetOverflow" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      (arg1)->unsetOverflow();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_unsetEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_unsetEnd" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      (arg1)->unsetEnd();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_end" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      result = (bool)((gum::Instantiation const *)arg1)->end();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_rend" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      result = (bool)((gum::Instantiation const *)arg1)->rend();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_inc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_inc" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      (arg1)->inc();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_dec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_dec" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      (arg1)->dec();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_incIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_incIn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_incIn" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_incIn" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_incIn" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      (arg1)->incIn((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_decIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_decIn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_decIn" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_decIn" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_decIn" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      (arg1)->decIn((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_incOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_incOut", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_incOut" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_incOut" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_incOut" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      (arg1)->incOut((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_decOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_decOut", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_decOut" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_decOut" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_decOut" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      (arg1)->decOut((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_incNotVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_incNotVar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_incNotVar" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_incNotVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_incNotVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      (arg1)->incNotVar((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_decNotVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_decNotVar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_decNotVar" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_decNotVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_decNotVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      (arg1)->decNotVar((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_incVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_incVar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_incVar" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_incVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_incVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      (arg1)->incVar((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_decVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_decVar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_decVar" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_decVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_decVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      (arg1)->decVar((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_setFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_setFirst" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      (arg1)->setFirst();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_setLast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_setLast" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      (arg1)->setLast();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_setFirstIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_setFirstIn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_setFirstIn" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_setFirstIn" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_setFirstIn" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      (arg1)->setFirstIn((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_setLastIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_setLastIn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_setLastIn" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_setLastIn" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_setLastIn" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      (arg1)->setLastIn((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_setFirstOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_setFirstOut", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_setFirstOut" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_setFirstOut" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_setFirstOut" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      (arg1)->setFirstOut((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_setLastOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_setLastOut", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_setLastOut" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_setLastOut" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_setLastOut" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      (arg1)->setLastOut((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_setFirstNotVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_setFirstNotVar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_setFirstNotVar" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_setFirstNotVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_setFirstNotVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      (arg1)->setFirstNotVar((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_setLastNotVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_setLastNotVar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_setLastNotVar" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_setLastNotVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_setLastNotVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      (arg1)->setLastNotVar((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_setFirstVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_setFirstVar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_setFirstVar" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_setFirstVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_setFirstVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      (arg1)->setFirstVar((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_setLastVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_setLastVar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_setLastVar" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_setLastVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_setLastVar" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      (arg1)->setLastVar((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation___eq__" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation___eq__" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation___eq__" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      result = (bool)((gum::Instantiation const *)arg1)->operator ==((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Instantiation___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Instantiation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation___iadd__" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Instantiation___iadd__" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = (gum::Instantiation *) &(arg1)->operator +=(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Instantiation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation___isub__" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Instantiation___isub__" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = (gum::Instantiation *) &(arg1)->operator -=(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_hamming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Idx result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_hamming" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      result = ((gum::Instantiation const *)arg1)->hamming();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_reorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Sequence< gum::DiscreteVariable const * > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_reorder" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__SequenceT_gum__DiscreteVariable_const_p_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_reorder" "', argument " "2"" of type '" "gum::Sequence< gum::DiscreteVariable const * > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_reorder" "', argument " "2"" of type '" "gum::Sequence< gum::DiscreteVariable const * > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Sequence< gum::DiscreteVariable const * > * >(argp2);
  {
    try {
      (arg1)->reorder((gum::Sequence< gum::DiscreteVariable const * > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_reorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_reorder" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instantiation_reorder" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Instantiation_reorder" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      (arg1)->reorder((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_reorder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Instantiation_reorder", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__Instantiation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__SequenceT_gum__DiscreteVariable_const_p_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Instantiation_reorder__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__Instantiation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Instantiation_reorder__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Instantiation_reorder'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Instantiation::reorder(gum::Sequence< gum::DiscreteVariable const * > const &)\n"
    "    gum::Instantiation::reorder(gum::Instantiation const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Instantiation___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation___repr__" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      result = gum_Instantiation___repr__((gum::Instantiation const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation___str__" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      result = gum_Instantiation___str__((gum::Instantiation const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_todict__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_todict" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Instantiation_todict" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (PyObject *)gum_Instantiation_todict__SWIG_0((gum::Instantiation const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_todict__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_todict" "', argument " "1"" of type '" "gum::Instantiation const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  {
    try {
      result = (PyObject *)gum_Instantiation_todict__SWIG_0((gum::Instantiation const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instantiation_todict(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Instantiation_todict", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__Instantiation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Instantiation_todict__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__Instantiation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Instantiation_todict__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Instantiation_todict'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Instantiation::todict(bool) const\n"
    "    gum::Instantiation::todict() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Instantiation_fromdict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Instantiation *arg1 = (gum::Instantiation *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instantiation_fromdict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instantiation_fromdict" "', argument " "1"" of type '" "gum::Instantiation *""'"); 
  }
  arg1 = reinterpret_cast< gum::Instantiation * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_Instantiation_fromdict(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Instantiation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__Instantiation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Instantiation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

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


SWIGINTERN PyObject *Swig_var___list_end_safe_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(gum::__list_end_safe), SWIGTYPE_p_void,  0 );
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var___list_end_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(gum::__list_end), SWIGTYPE_p_void,  0 );
  return pyobj;
}


SWIGINTERN PyObject *_wrap_delete_DAGmodel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DAGmodel" "', argument " "1"" of type '" "gum::DAGmodel *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_property(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::string *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DAGmodel_property", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_property" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DAGmodel_property" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DAGmodel_property" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::string *) &((gum::DAGmodel const *)arg1)->property((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_propertyWithDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  std::string *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DAGmodel_propertyWithDefault", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_propertyWithDefault" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DAGmodel_propertyWithDefault" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DAGmodel_propertyWithDefault" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DAGmodel_propertyWithDefault" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DAGmodel_propertyWithDefault" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (std::string *) &((gum::DAGmodel const *)arg1)->propertyWithDefault((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_setProperty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DAGmodel_setProperty", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_setProperty" "', argument " "1"" of type '" "gum::DAGmodel *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DAGmodel_setProperty" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DAGmodel_setProperty" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DAGmodel_setProperty" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DAGmodel_setProperty" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->setProperty((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_dag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DAG *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_dag" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = (gum::DAG *) &((gum::DAGmodel const *)arg1)->dag();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DAG, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_variableNodeMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VariableNodeMap *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_variableNodeMap" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = (gum::VariableNodeMap *) &((gum::DAGmodel const *)arg1)->variableNodeMap();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__VariableNodeMap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_size" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->size();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_sizeArcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_sizeArcs" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->sizeArcs();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_empty" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = (bool)((gum::DAGmodel const *)arg1)->empty();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_nodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeGraphPart *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_nodes" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = (gum::NodeGraphPart *) &((gum::DAGmodel const *)arg1)->nodes();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NodeGraphPart, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_variable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DAGmodel_variable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_variable" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DAGmodel_variable" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::DAGmodel const *)arg1)->variable(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_nodeId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "DAGmodel_nodeId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_nodeId" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DAGmodel_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DAGmodel_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->nodeId((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_idFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "DAGmodel_idFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_idFromName" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DAGmodel_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DAGmodel_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->idFromName((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_variableFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DAGmodel_variableFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_variableFromName" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DAGmodel_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DAGmodel_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::DAGmodel const *)arg1)->variableFromName((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_completeInstantiation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Instantiation result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_completeInstantiation" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = ((gum::DAGmodel const *)arg1)->completeInstantiation();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Instantiation(static_cast< const gum::Instantiation& >(result))), SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_arcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::ArcSet *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_arcs" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = (gum::ArcSet *) &((gum::DAGmodel const *)arg1)->arcs();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SetT_gum__Arc_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_parents__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::NodeSet *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_parents" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DAGmodel_parents" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::NodeSet *) &((gum::DAGmodel const *)arg1)->parents(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SetT_std__size_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_parents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::NodeSet *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_parents" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DAGmodel_parents" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DAGmodel_parents" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::NodeSet *) &((gum::DAGmodel const *)arg1)->parents((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SetT_std__size_t_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_parents(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAGmodel_parents", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DAGmodel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DAGmodel_parents__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DAGmodel, 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_DAGmodel_parents__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAGmodel_parents'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAGmodel::parents(gum::NodeId const) const\n"
    "    gum::DAGmodel::parents(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAGmodel_children__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::NodeSet *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_children" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DAGmodel_children" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::NodeSet *) &((gum::DAGmodel const *)arg1)->children(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SetT_std__size_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_children__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::NodeSet *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_children" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DAGmodel_children" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DAGmodel_children" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::NodeSet *) &((gum::DAGmodel const *)arg1)->children((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SetT_std__size_t_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_children(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAGmodel_children", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DAGmodel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DAGmodel_children__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DAGmodel, 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_DAGmodel_children__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAGmodel_children'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAGmodel::children(gum::NodeId const) const\n"
    "    gum::DAGmodel::children(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAGmodel_moralGraph__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  gum::UndiGraph *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_moralGraph" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DAGmodel_moralGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::UndiGraph *) &((gum::DAGmodel const *)arg1)->moralGraph(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_moralGraph__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::UndiGraph *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_moralGraph" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = (gum::UndiGraph *) &((gum::DAGmodel const *)arg1)->moralGraph();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__UndiGraph, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_moralGraph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAGmodel_moralGraph", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DAGmodel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DAGmodel_moralGraph__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DAGmodel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DAGmodel_moralGraph__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAGmodel_moralGraph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAGmodel::moralGraph(bool) const\n"
    "    gum::DAGmodel::moralGraph() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAGmodel_topologicalOrder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  gum::Sequence< gum::NodeId > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_topologicalOrder" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DAGmodel_topologicalOrder" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (gum::Sequence< gum::NodeId > *) &((gum::DAGmodel const *)arg1)->topologicalOrder(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    PyObject *q=PyList_New(0);
    for(auto i : *result) {
      PyList_Append(q,PyInt_FromLong(i));
    }
    resultobj=q;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_topologicalOrder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Sequence< gum::NodeId > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_topologicalOrder" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = (gum::Sequence< gum::NodeId > *) &((gum::DAGmodel const *)arg1)->topologicalOrder();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    PyObject *q=PyList_New(0);
    for(auto i : *result) {
      PyList_Append(q,PyInt_FromLong(i));
    }
    resultobj=q;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_topologicalOrder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DAGmodel_topologicalOrder", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DAGmodel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DAGmodel_topologicalOrder__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__DAGmodel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DAGmodel_topologicalOrder__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DAGmodel_topologicalOrder'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DAGmodel::topologicalOrder(bool) const\n"
    "    gum::DAGmodel::topologicalOrder() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DAGmodel_log10DomainSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_log10DomainSize" "', argument " "1"" of type '" "gum::DAGmodel const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = (double)((gum::DAGmodel const *)arg1)->log10DomainSize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DAGmodel_hasSameStructure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = (gum::DAGmodel *) 0 ;
  gum::DAGmodel *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "DAGmodel_hasSameStructure", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DAGmodel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DAGmodel_hasSameStructure" "', argument " "1"" of type '" "gum::DAGmodel *""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DAGmodel,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DAGmodel_hasSameStructure" "', argument " "2"" of type '" "gum::DAGmodel const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DAGmodel_hasSameStructure" "', argument " "2"" of type '" "gum::DAGmodel const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DAGmodel * >(argp2);
  {
    try {
      result = (bool)(arg1)->hasSameStructure((gum::DAGmodel const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DAGmodel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__DAGmodel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EssentialGraph__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (gum::EssentialGraph *)new gum::EssentialGraph();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__EssentialGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EssentialGraph__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::EssentialGraph *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__DAGmodel,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EssentialGraph" "', argument " "1"" of type '" "gum::DAGmodel const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EssentialGraph" "', argument " "1"" of type '" "gum::DAGmodel const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    try {
      result = (gum::EssentialGraph *)new gum::EssentialGraph((gum::DAGmodel const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__EssentialGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EssentialGraph__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  gum::MixedGraph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::EssentialGraph *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__DAGmodel,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EssentialGraph" "', argument " "1"" of type '" "gum::DAGmodel const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EssentialGraph" "', argument " "1"" of type '" "gum::DAGmodel const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__MixedGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EssentialGraph" "', argument " "2"" of type '" "gum::MixedGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EssentialGraph" "', argument " "2"" of type '" "gum::MixedGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MixedGraph * >(argp2);
  {
    try {
      result = (gum::EssentialGraph *)new gum::EssentialGraph((gum::DAGmodel const &)*arg1,(gum::MixedGraph const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__EssentialGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EssentialGraph__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::EssentialGraph *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__EssentialGraph,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EssentialGraph" "', argument " "1"" of type '" "gum::EssentialGraph const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EssentialGraph" "', argument " "1"" of type '" "gum::EssentialGraph const &""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = (gum::EssentialGraph *)new gum::EssentialGraph((gum::EssentialGraph const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__EssentialGraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EssentialGraph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EssentialGraph", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EssentialGraph__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DAGmodel, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EssentialGraph__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__EssentialGraph, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EssentialGraph__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DAGmodel, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_EssentialGraph__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EssentialGraph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::EssentialGraph::EssentialGraph()\n"
    "    gum::EssentialGraph::EssentialGraph(gum::DAGmodel const &)\n"
    "    gum::EssentialGraph::EssentialGraph(gum::DAGmodel const &,gum::MixedGraph const &)\n"
    "    gum::EssentialGraph::EssentialGraph(gum::EssentialGraph const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EssentialGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = (gum::EssentialGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__EssentialGraph, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EssentialGraph" "', argument " "1"" of type '" "gum::EssentialGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_mixedGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = (gum::EssentialGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::MixedGraph result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_mixedGraph" "', argument " "1"" of type '" "gum::EssentialGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = (arg1)->mixedGraph();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::MixedGraph(static_cast< const gum::MixedGraph& >(result))), SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_toDot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = (gum::EssentialGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_toDot" "', argument " "1"" of type '" "gum::EssentialGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = ((gum::EssentialGraph const *)arg1)->toDot();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_sizeArcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = (gum::EssentialGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_sizeArcs" "', argument " "1"" of type '" "gum::EssentialGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = ((gum::EssentialGraph const *)arg1)->sizeArcs();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_sizeEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = (gum::EssentialGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_sizeEdges" "', argument " "1"" of type '" "gum::EssentialGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = ((gum::EssentialGraph const *)arg1)->sizeEdges();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_sizeNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = (gum::EssentialGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_sizeNodes" "', argument " "1"" of type '" "gum::EssentialGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = ((gum::EssentialGraph const *)arg1)->sizeNodes();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = (gum::EssentialGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_size" "', argument " "1"" of type '" "gum::EssentialGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = ((gum::EssentialGraph const *)arg1)->size();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_nodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = (gum::EssentialGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_nodes" "', argument " "1"" of type '" "gum::EssentialGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = (PyObject *)gum_EssentialGraph_nodes((gum::EssentialGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_arcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = (gum::EssentialGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_arcs" "', argument " "1"" of type '" "gum::EssentialGraph const *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = (PyObject *)gum_EssentialGraph_arcs((gum::EssentialGraph const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_parents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = (gum::EssentialGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "EssentialGraph_parents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_parents" "', argument " "1"" of type '" "gum::EssentialGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EssentialGraph_parents" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_EssentialGraph_parents(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_children(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = (gum::EssentialGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "EssentialGraph_children", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_children" "', argument " "1"" of type '" "gum::EssentialGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EssentialGraph_children" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_EssentialGraph_children(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_edges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = (gum::EssentialGraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_edges" "', argument " "1"" of type '" "gum::EssentialGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  {
    try {
      result = (PyObject *)gum_EssentialGraph_edges(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EssentialGraph_neighbours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::EssentialGraph *arg1 = (gum::EssentialGraph *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "EssentialGraph_neighbours", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__EssentialGraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EssentialGraph_neighbours" "', argument " "1"" of type '" "gum::EssentialGraph *""'"); 
  }
  arg1 = reinterpret_cast< gum::EssentialGraph * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EssentialGraph_neighbours" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_EssentialGraph_neighbours(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EssentialGraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__EssentialGraph, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EssentialGraph_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MarkovBlanket__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::MarkovBlanket *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__DAGmodel,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarkovBlanket" "', argument " "1"" of type '" "gum::DAGmodel const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovBlanket" "', argument " "1"" of type '" "gum::DAGmodel const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MarkovBlanket" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::MarkovBlanket *)new gum::MarkovBlanket((gum::DAGmodel const &)*arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MarkovBlanket, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarkovBlanket__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DAGmodel *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::MarkovBlanket *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__DAGmodel,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarkovBlanket" "', argument " "1"" of type '" "gum::DAGmodel const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovBlanket" "', argument " "1"" of type '" "gum::DAGmodel const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DAGmodel * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MarkovBlanket" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovBlanket" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::MarkovBlanket *)new gum::MarkovBlanket((gum::DAGmodel const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MarkovBlanket, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarkovBlanket(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MarkovBlanket", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DAGmodel, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MarkovBlanket__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DAGmodel, SWIG_POINTER_NO_NULL | 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_MarkovBlanket__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MarkovBlanket'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MarkovBlanket::MarkovBlanket(gum::DAGmodel const &,gum::NodeId)\n"
    "    gum::MarkovBlanket::MarkovBlanket(gum::DAGmodel const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MarkovBlanket(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = (gum::MarkovBlanket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovBlanket, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkovBlanket" "', argument " "1"" of type '" "gum::MarkovBlanket *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovBlanket * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_mb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = (gum::MarkovBlanket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DiGraph result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovBlanket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovBlanket_mb" "', argument " "1"" of type '" "gum::MarkovBlanket *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovBlanket * >(argp1);
  {
    try {
      result = (arg1)->mb();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::DiGraph(static_cast< const gum::DiGraph& >(result))), SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_toDot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = (gum::MarkovBlanket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovBlanket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovBlanket_toDot" "', argument " "1"" of type '" "gum::MarkovBlanket const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovBlanket * >(argp1);
  {
    try {
      result = ((gum::MarkovBlanket const *)arg1)->toDot();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_sizeArcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = (gum::MarkovBlanket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovBlanket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovBlanket_sizeArcs" "', argument " "1"" of type '" "gum::MarkovBlanket const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovBlanket * >(argp1);
  {
    try {
      result = ((gum::MarkovBlanket const *)arg1)->sizeArcs();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_sizeNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = (gum::MarkovBlanket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovBlanket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovBlanket_sizeNodes" "', argument " "1"" of type '" "gum::MarkovBlanket const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovBlanket * >(argp1);
  {
    try {
      result = ((gum::MarkovBlanket const *)arg1)->sizeNodes();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = (gum::MarkovBlanket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovBlanket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovBlanket_size" "', argument " "1"" of type '" "gum::MarkovBlanket const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovBlanket * >(argp1);
  {
    try {
      result = ((gum::MarkovBlanket const *)arg1)->size();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_hasSameStructure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = (gum::MarkovBlanket *) 0 ;
  gum::DAGmodel *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "MarkovBlanket_hasSameStructure", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovBlanket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovBlanket_hasSameStructure" "', argument " "1"" of type '" "gum::MarkovBlanket *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovBlanket * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DAGmodel,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkovBlanket_hasSameStructure" "', argument " "2"" of type '" "gum::DAGmodel const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovBlanket_hasSameStructure" "', argument " "2"" of type '" "gum::DAGmodel const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DAGmodel * >(argp2);
  {
    try {
      result = (bool)(arg1)->hasSameStructure((gum::DAGmodel const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_nodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = (gum::MarkovBlanket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovBlanket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovBlanket_nodes" "', argument " "1"" of type '" "gum::MarkovBlanket const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovBlanket * >(argp1);
  {
    try {
      result = (PyObject *)gum_MarkovBlanket_nodes((gum::MarkovBlanket const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_arcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = (gum::MarkovBlanket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovBlanket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovBlanket_arcs" "', argument " "1"" of type '" "gum::MarkovBlanket const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovBlanket * >(argp1);
  {
    try {
      result = (PyObject *)gum_MarkovBlanket_arcs((gum::MarkovBlanket const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_parents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = (gum::MarkovBlanket *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "MarkovBlanket_parents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovBlanket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovBlanket_parents" "', argument " "1"" of type '" "gum::MarkovBlanket *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovBlanket * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkovBlanket_parents" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_MarkovBlanket_parents(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovBlanket_children(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MarkovBlanket *arg1 = (gum::MarkovBlanket *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "MarkovBlanket_children", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MarkovBlanket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovBlanket_children" "', argument " "1"" of type '" "gum::MarkovBlanket *""'"); 
  }
  arg1 = reinterpret_cast< gum::MarkovBlanket * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkovBlanket_children" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_MarkovBlanket_children(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MarkovBlanket_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__MarkovBlanket, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MarkovBlanket_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_StructuralComparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_StructuralComparator", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (gum::StructuralComparator *)new gum::StructuralComparator();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__StructuralComparator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StructuralComparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = (gum::StructuralComparator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__StructuralComparator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StructuralComparator" "', argument " "1"" of type '" "gum::StructuralComparator *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralComparator * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralComparator_compare__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = (gum::StructuralComparator *) 0 ;
  gum::DiGraph *arg2 = 0 ;
  gum::DiGraph *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__StructuralComparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralComparator_compare" "', argument " "1"" of type '" "gum::StructuralComparator *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralComparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StructuralComparator_compare" "', argument " "2"" of type '" "gum::DiGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StructuralComparator_compare" "', argument " "2"" of type '" "gum::DiGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiGraph * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__DiGraph,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StructuralComparator_compare" "', argument " "3"" of type '" "gum::DiGraph const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StructuralComparator_compare" "', argument " "3"" of type '" "gum::DiGraph const &""'"); 
  }
  arg3 = reinterpret_cast< gum::DiGraph * >(argp3);
  {
    try {
      (arg1)->compare((gum::DiGraph const &)*arg2,(gum::DiGraph const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralComparator_compare__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = (gum::StructuralComparator *) 0 ;
  gum::UndiGraph *arg2 = 0 ;
  gum::UndiGraph *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__StructuralComparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralComparator_compare" "', argument " "1"" of type '" "gum::StructuralComparator *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralComparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__UndiGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StructuralComparator_compare" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StructuralComparator_compare" "', argument " "2"" of type '" "gum::UndiGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::UndiGraph * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__UndiGraph,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StructuralComparator_compare" "', argument " "3"" of type '" "gum::UndiGraph const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StructuralComparator_compare" "', argument " "3"" of type '" "gum::UndiGraph const &""'"); 
  }
  arg3 = reinterpret_cast< gum::UndiGraph * >(argp3);
  {
    try {
      (arg1)->compare((gum::UndiGraph const &)*arg2,(gum::UndiGraph const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralComparator_compare__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = (gum::StructuralComparator *) 0 ;
  gum::MixedGraph *arg2 = 0 ;
  gum::MixedGraph *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__StructuralComparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralComparator_compare" "', argument " "1"" of type '" "gum::StructuralComparator *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralComparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__MixedGraph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StructuralComparator_compare" "', argument " "2"" of type '" "gum::MixedGraph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StructuralComparator_compare" "', argument " "2"" of type '" "gum::MixedGraph const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MixedGraph * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__MixedGraph,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StructuralComparator_compare" "', argument " "3"" of type '" "gum::MixedGraph const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StructuralComparator_compare" "', argument " "3"" of type '" "gum::MixedGraph const &""'"); 
  }
  arg3 = reinterpret_cast< gum::MixedGraph * >(argp3);
  {
    try {
      (arg1)->compare((gum::MixedGraph const &)*arg2,(gum::MixedGraph const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralComparator_compare(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StructuralComparator_compare", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__StructuralComparator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StructuralComparator_compare__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__StructuralComparator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gum__UndiGraph, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StructuralComparator_compare__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__StructuralComparator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gum__DiGraph, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StructuralComparator_compare__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StructuralComparator_compare'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::StructuralComparator::compare(gum::DiGraph const &,gum::DiGraph const &)\n"
    "    gum::StructuralComparator::compare(gum::UndiGraph const &,gum::UndiGraph const &)\n"
    "    gum::StructuralComparator::compare(gum::MixedGraph const &,gum::MixedGraph const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StructuralComparator_precision_skeleton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = (gum::StructuralComparator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__StructuralComparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralComparator_precision_skeleton" "', argument " "1"" of type '" "gum::StructuralComparator const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralComparator * >(argp1);
  {
    try {
      result = (double)((gum::StructuralComparator const *)arg1)->precision_skeleton();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralComparator_recall_skeleton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = (gum::StructuralComparator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__StructuralComparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralComparator_recall_skeleton" "', argument " "1"" of type '" "gum::StructuralComparator const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralComparator * >(argp1);
  {
    try {
      result = (double)((gum::StructuralComparator const *)arg1)->recall_skeleton();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralComparator_f_score_skeleton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = (gum::StructuralComparator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__StructuralComparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralComparator_f_score_skeleton" "', argument " "1"" of type '" "gum::StructuralComparator const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralComparator * >(argp1);
  {
    try {
      result = (double)((gum::StructuralComparator const *)arg1)->f_score_skeleton();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralComparator_precision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = (gum::StructuralComparator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__StructuralComparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralComparator_precision" "', argument " "1"" of type '" "gum::StructuralComparator const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralComparator * >(argp1);
  {
    try {
      result = (double)((gum::StructuralComparator const *)arg1)->precision();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralComparator_recall(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = (gum::StructuralComparator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__StructuralComparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralComparator_recall" "', argument " "1"" of type '" "gum::StructuralComparator const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralComparator * >(argp1);
  {
    try {
      result = (double)((gum::StructuralComparator const *)arg1)->recall();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuralComparator_f_score(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::StructuralComparator *arg1 = (gum::StructuralComparator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__StructuralComparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StructuralComparator_f_score" "', argument " "1"" of type '" "gum::StructuralComparator const *""'"); 
  }
  arg1 = reinterpret_cast< gum::StructuralComparator * >(argp1);
  {
    try {
      result = (double)((gum::StructuralComparator const *)arg1)->f_score();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StructuralComparator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__StructuralComparator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *StructuralComparator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ApproximationScheme__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  gum::ApproximationScheme *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ApproximationScheme" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (gum::ApproximationScheme *)new gum::ApproximationScheme(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ApproximationScheme, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApproximationScheme__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (gum::ApproximationScheme *)new gum::ApproximationScheme();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ApproximationScheme, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApproximationScheme(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ApproximationScheme", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ApproximationScheme__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ApproximationScheme__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ApproximationScheme'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ApproximationScheme::ApproximationScheme(bool)\n"
    "    gum::ApproximationScheme::ApproximationScheme()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApproximationScheme" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_setEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ApproximationScheme_setEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_setEpsilon" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ApproximationScheme_setEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      (arg1)->setEpsilon(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_epsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_epsilon" "', argument " "1"" of type '" "gum::ApproximationScheme const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = (double)((gum::ApproximationScheme const *)arg1)->epsilon();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_disableEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_disableEpsilon" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      (arg1)->disableEpsilon();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_enableEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_enableEpsilon" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      (arg1)->enableEpsilon();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_isEnabledEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_isEnabledEpsilon" "', argument " "1"" of type '" "gum::ApproximationScheme const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = (bool)((gum::ApproximationScheme const *)arg1)->isEnabledEpsilon();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_setMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ApproximationScheme_setMinEpsilonRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_setMinEpsilonRate" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ApproximationScheme_setMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      (arg1)->setMinEpsilonRate(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_minEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_minEpsilonRate" "', argument " "1"" of type '" "gum::ApproximationScheme const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = (double)((gum::ApproximationScheme const *)arg1)->minEpsilonRate();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_disableMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_disableMinEpsilonRate" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      (arg1)->disableMinEpsilonRate();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_enableMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_enableMinEpsilonRate" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      (arg1)->enableMinEpsilonRate();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_isEnabledMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_isEnabledMinEpsilonRate" "', argument " "1"" of type '" "gum::ApproximationScheme const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = (bool)((gum::ApproximationScheme const *)arg1)->isEnabledMinEpsilonRate();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_setMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ApproximationScheme_setMaxIter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_setMaxIter" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ApproximationScheme_setMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      (arg1)->setMaxIter(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_maxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_maxIter" "', argument " "1"" of type '" "gum::ApproximationScheme const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = ((gum::ApproximationScheme const *)arg1)->maxIter();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_disableMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_disableMaxIter" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      (arg1)->disableMaxIter();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_enableMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_enableMaxIter" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      (arg1)->enableMaxIter();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_isEnabledMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_isEnabledMaxIter" "', argument " "1"" of type '" "gum::ApproximationScheme const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = (bool)((gum::ApproximationScheme const *)arg1)->isEnabledMaxIter();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_setMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ApproximationScheme_setMaxTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_setMaxTime" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ApproximationScheme_setMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      (arg1)->setMaxTime(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_maxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_maxTime" "', argument " "1"" of type '" "gum::ApproximationScheme const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = (double)((gum::ApproximationScheme const *)arg1)->maxTime();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_currentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_currentTime" "', argument " "1"" of type '" "gum::ApproximationScheme const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = (double)((gum::ApproximationScheme const *)arg1)->currentTime();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_disableMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_disableMaxTime" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      (arg1)->disableMaxTime();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_enableMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_enableMaxTime" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      (arg1)->enableMaxTime();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_isEnabledMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_isEnabledMaxTime" "', argument " "1"" of type '" "gum::ApproximationScheme const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = (bool)((gum::ApproximationScheme const *)arg1)->isEnabledMaxTime();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_setPeriodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ApproximationScheme_setPeriodSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_setPeriodSize" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ApproximationScheme_setPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      (arg1)->setPeriodSize(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_periodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_periodSize" "', argument " "1"" of type '" "gum::ApproximationScheme const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = ((gum::ApproximationScheme const *)arg1)->periodSize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_setVerbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ApproximationScheme_setVerbosity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_setVerbosity" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ApproximationScheme_setVerbosity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setVerbosity(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_verbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_verbosity" "', argument " "1"" of type '" "gum::ApproximationScheme const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = (bool)((gum::ApproximationScheme const *)arg1)->verbosity();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_stateApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration::ApproximationSchemeSTATE result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_stateApproximationScheme" "', argument " "1"" of type '" "gum::ApproximationScheme const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration::ApproximationSchemeSTATE)((gum::ApproximationScheme const *)arg1)->stateApproximationScheme();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_nbrIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_nbrIterations" "', argument " "1"" of type '" "gum::ApproximationScheme const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = ((gum::ApproximationScheme const *)arg1)->nbrIterations();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_history" "', argument " "1"" of type '" "gum::ApproximationScheme const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &((gum::ApproximationScheme const *)arg1)->history();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_initApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_initApproximationScheme" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      (arg1)->initApproximationScheme();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_startOfPeriod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_startOfPeriod" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = (bool)(arg1)->startOfPeriod();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_updateApproximationScheme__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_updateApproximationScheme" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ApproximationScheme_updateApproximationScheme" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      (arg1)->updateApproximationScheme(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_updateApproximationScheme__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_updateApproximationScheme" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      (arg1)->updateApproximationScheme();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_updateApproximationScheme(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ApproximationScheme_updateApproximationScheme", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ApproximationScheme, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ApproximationScheme_updateApproximationScheme__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ApproximationScheme, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ApproximationScheme_updateApproximationScheme__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ApproximationScheme_updateApproximationScheme'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ApproximationScheme::updateApproximationScheme(unsigned int)\n"
    "    gum::ApproximationScheme::updateApproximationScheme()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_remainingBurnIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_remainingBurnIn" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      result = (arg1)->remainingBurnIn();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_stopApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_stopApproximationScheme" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  {
    try {
      (arg1)->stopApproximationScheme();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ApproximationScheme_continueApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ApproximationScheme *arg1 = (gum::ApproximationScheme *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ApproximationScheme_continueApproximationScheme", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ApproximationScheme, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ApproximationScheme_continueApproximationScheme" "', argument " "1"" of type '" "gum::ApproximationScheme *""'"); 
  }
  arg1 = reinterpret_cast< gum::ApproximationScheme * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ApproximationScheme_continueApproximationScheme" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (bool)(arg1)->continueApproximationScheme(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ApproximationScheme_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__ApproximationScheme, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ApproximationScheme_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_randomDistribution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "randomDistribution" "', argument " "1"" of type '" "gum::Size""'");
  } 
  arg1 = static_cast< gum::Size >(val1);
  {
    try {
      result = gum::SWIGTEMPLATEDISAMBIGUATOR randomDistribution< double >(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretizedVariable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  gum::DiscretizedVariable< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscretizedVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscretizedVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DiscretizedVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscretizedVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscretizedVariable< double > *)new gum::DiscretizedVariable< double >((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscretizedVariableT_double_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretizedVariable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::DiscretizedVariable< double > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscretizedVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscretizedVariable" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DiscretizedVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscretizedVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DiscretizedVariable" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscretizedVariable" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (gum::DiscretizedVariable< double > *)new gum::DiscretizedVariable< double >((std::string const &)*arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscretizedVariableT_double_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretizedVariable__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::DiscretizedVariable< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__DiscretizedVariableT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscretizedVariable" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscretizedVariable" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  {
    try {
      result = (gum::DiscretizedVariable< double > *)new gum::DiscretizedVariable< double >((gum::DiscretizedVariable< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscretizedVariableT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretizedVariable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DiscretizedVariable", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__DiscretizedVariableT_double_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretizedVariable__SWIG_2(self, argc, argv);
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DiscretizedVariable__SWIG_0(self, argc, argv);
      }
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_DiscretizedVariable__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DiscretizedVariable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::DiscretizedVariable< double >::DiscretizedVariable(std::string const &,std::string const &)\n"
    "    gum::DiscretizedVariable< double >::DiscretizedVariable(std::string const &,std::string const &,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::DiscretizedVariable< double >::DiscretizedVariable(gum::DiscretizedVariable< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DiscretizedVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = (gum::DiscretizedVariable< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscretizedVariableT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscretizedVariable" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = (gum::DiscretizedVariable< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DiscretizedVariable< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscretizedVariable_clone" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  {
    try {
      result = (gum::DiscretizedVariable< double > *)((gum::DiscretizedVariable< double > const *)arg1)->clone();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_varType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = (gum::DiscretizedVariable< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VarType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscretizedVariable_varType" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  {
    try {
      result = (gum::VarType)((gum::DiscretizedVariable< double > const *)arg1)->varType();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_isTick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = (gum::DiscretizedVariable< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "DiscretizedVariable_isTick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscretizedVariable_isTick" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscretizedVariable_isTick" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (bool)((gum::DiscretizedVariable< double > const *)arg1)->isTick((double const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_addTick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = (gum::DiscretizedVariable< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::DiscretizedVariable< double > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DiscretizedVariable_addTick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscretizedVariable_addTick" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscretizedVariable_addTick" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (gum::DiscretizedVariable< double > *) &(arg1)->addTick((double const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_eraseTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = (gum::DiscretizedVariable< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscretizedVariable_eraseTicks" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  {
    try {
      (arg1)->eraseTicks();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_label(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = (gum::DiscretizedVariable< double > *) 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "DiscretizedVariable_label", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscretizedVariable_label" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscretizedVariable_label" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = ((gum::DiscretizedVariable< double > const *)arg1)->label(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_numerical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = (gum::DiscretizedVariable< double > *) 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "DiscretizedVariable_numerical", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscretizedVariable_numerical" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscretizedVariable_numerical" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = (double)((gum::DiscretizedVariable< double > const *)arg1)->numerical(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = (gum::DiscretizedVariable< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  if (!SWIG_Python_UnpackTuple(args, "DiscretizedVariable_index", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscretizedVariable_index" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscretizedVariable_index" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscretizedVariable_index" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::DiscretizedVariable< double > const *)arg1)->index((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_domainSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = (gum::DiscretizedVariable< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscretizedVariable_domainSize" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  {
    try {
      result = ((gum::DiscretizedVariable< double > const *)arg1)->domainSize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_domain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = (gum::DiscretizedVariable< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscretizedVariable_domain" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  {
    try {
      result = ((gum::DiscretizedVariable< double > const *)arg1)->domain();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_tick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = (gum::DiscretizedVariable< double > *) 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DiscretizedVariable_tick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscretizedVariable_tick" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscretizedVariable_tick" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = (double *) &((gum::DiscretizedVariable< double > const *)arg1)->tick(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable_ticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = (gum::DiscretizedVariable< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscretizedVariable_ticks" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &((gum::DiscretizedVariable< double > const *)arg1)->ticks();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = (gum::DiscretizedVariable< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscretizedVariable___repr__" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  {
    try {
      result = gum_DiscretizedVariable_Sl_double_Sg____repr__((gum::DiscretizedVariable< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscretizedVariable___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::DiscretizedVariable< double > *arg1 = (gum::DiscretizedVariable< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__DiscretizedVariableT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscretizedVariable___str__" "', argument " "1"" of type '" "gum::DiscretizedVariable< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::DiscretizedVariable< double > * >(argp1);
  {
    try {
      result = gum_DiscretizedVariable_Sl_double_Sg____str__((gum::DiscretizedVariable< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DiscretizedVariable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__DiscretizedVariableT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DiscretizedVariable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_MultiDimContainer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MultiDimContainer" "', argument " "1"" of type '" "gum::MultiDimContainer< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MultiDimContainer_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_set" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiDimContainer_set" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiDimContainer_set" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MultiDimContainer_set" "', argument " "3"" of type '" "double""'");
  } 
  temp3 = static_cast< double >(val3);
  arg3 = &temp3;
  {
    try {
      ((gum::MultiDimContainer< double > const *)arg1)->set((gum::Instantiation const &)*arg2,(double const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "MultiDimContainer_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_get" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiDimContainer_get" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiDimContainer_get" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      result = (double)((gum::MultiDimContainer< double > const *)arg1)->get((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MultiDimContainer_fill", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_fill" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MultiDimContainer_fill" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      ((gum::MultiDimContainer< double > const *)arg1)->fill((double const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_populate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_populate" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiDimContainer_populate" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiDimContainer_populate" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      ((gum::MultiDimContainer< double > const *)arg1)->populate((std::vector< double,std::allocator< double > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_populate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  SwigValueWrapper< std::initializer_list< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_populate" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  
  {
    try {
      ((gum::MultiDimContainer< double > const *)arg1)->populate(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_populate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MultiDimContainer_populate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      if (_v) {
        return _wrap_MultiDimContainer_populate__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MultiDimContainer_populate__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MultiDimContainer_populate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MultiDimContainer< double >::populate(std::vector< double,std::allocator< double > > const &) const\n"
    "    gum::MultiDimContainer< double >::populate(std::initializer_list< double >) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_copyFrom__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  gum::MultiDimContainer< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_copyFrom" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__MultiDimContainerT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiDimContainer_copyFrom" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiDimContainer_copyFrom" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp2);
  {
    try {
      ((gum::MultiDimContainer< double > const *)arg1)->copyFrom((gum::MultiDimContainer< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_copyFrom__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  gum::MultiDimContainer< double > *arg2 = 0 ;
  gum::Instantiation *arg3 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_copyFrom" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__MultiDimContainerT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiDimContainer_copyFrom" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiDimContainer_copyFrom" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MultiDimContainer_copyFrom" "', argument " "3"" of type '" "gum::Instantiation *""'"); 
  }
  arg3 = reinterpret_cast< gum::Instantiation * >(argp3);
  {
    try {
      ((gum::MultiDimContainer< double > const *)arg1)->copyFrom((gum::MultiDimContainer< double > const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_copyFrom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MultiDimContainer_copyFrom", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__MultiDimContainerT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MultiDimContainer_copyFrom__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__MultiDimContainerT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_gum__Instantiation, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MultiDimContainer_copyFrom__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MultiDimContainer_copyFrom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MultiDimContainer< double >::copyFrom(gum::MultiDimContainer< double > const &) const\n"
    "    gum::MultiDimContainer< double >::copyFrom(gum::MultiDimContainer< double > const &,gum::Instantiation *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_extractFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  gum::MultiDimContainer< double > *arg2 = 0 ;
  gum::Instantiation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MultiDimContainer_extractFrom", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_extractFrom" "', argument " "1"" of type '" "gum::MultiDimContainer< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__MultiDimContainerT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiDimContainer_extractFrom" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiDimContainer_extractFrom" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MultiDimContainer_extractFrom" "', argument " "3"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiDimContainer_extractFrom" "', argument " "3"" of type '" "gum::Instantiation const &""'"); 
  }
  arg3 = reinterpret_cast< gum::Instantiation * >(argp3);
  {
    try {
      (arg1)->extractFrom((gum::MultiDimContainer< double > const &)*arg2,(gum::Instantiation const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_content__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::MultiDimImplementation< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_content" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  {
    try {
      result = (gum::MultiDimImplementation< double > *)((gum::MultiDimContainer< double > const *)arg1)->content();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_content__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::MultiDimImplementation< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_content" "', argument " "1"" of type '" "gum::MultiDimContainer< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  {
    try {
      result = (gum::MultiDimImplementation< double > *)(arg1)->content();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_content(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MultiDimContainer_content", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MultiDimContainer_content__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MultiDimContainer_content__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MultiDimContainer_content'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MultiDimContainer< double >::content() const\n"
    "    gum::MultiDimContainer< double >::content()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_getMasterRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::MultiDimAdressable *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_getMasterRef" "', argument " "1"" of type '" "gum::MultiDimContainer< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  {
    try {
      result = (gum::MultiDimAdressable *) &(arg1)->getMasterRef();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MultiDimAdressable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_getMasterRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::MultiDimAdressable *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_getMasterRef" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  {
    try {
      result = (gum::MultiDimAdressable *) &((gum::MultiDimContainer< double > const *)arg1)->getMasterRef();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MultiDimAdressable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_getMasterRef(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MultiDimContainer_getMasterRef", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MultiDimContainer_getMasterRef__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MultiDimContainer_getMasterRef__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MultiDimContainer_getMasterRef'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MultiDimContainer< double >::getMasterRef()\n"
    "    gum::MultiDimContainer< double >::getMasterRef() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  gum::MultiDimContainer< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MultiDimContainer_copy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_copy" "', argument " "1"" of type '" "gum::MultiDimContainer< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__MultiDimContainerT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiDimContainer_copy" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiDimContainer_copy" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp2);
  {
    try {
      (arg1)->copy((gum::MultiDimContainer< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_newFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::MultiDimContainer< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_newFactory" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  {
    try {
      result = (gum::MultiDimContainer< double > *)((gum::MultiDimContainer< double > const *)arg1)->newFactory();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_toString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_toString" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  {
    try {
      result = ((gum::MultiDimContainer< double > const *)arg1)->toString();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_toString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  gum::Instantiation *arg2 = (gum::Instantiation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_toString" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_gum__Instantiation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiDimContainer_toString" "', argument " "2"" of type '" "gum::Instantiation const *""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      result = ((gum::MultiDimContainer< double > const *)arg1)->toString((gum::Instantiation const *)arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_toString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MultiDimContainer_toString", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MultiDimContainer_toString__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_gum__Instantiation, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MultiDimContainer_toString__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MultiDimContainer_toString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MultiDimContainer< double >::toString() const\n"
    "    gum::MultiDimContainer< double >::toString(gum::Instantiation const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  gum::MultiDimContainer< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "MultiDimContainer___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer___eq__" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__MultiDimContainerT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiDimContainer___eq__" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiDimContainer___eq__" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp2);
  {
    try {
      result = (bool)((gum::MultiDimContainer< double > const *)arg1)->operator ==((gum::MultiDimContainer< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  gum::MultiDimContainer< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "MultiDimContainer___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer___ne__" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__MultiDimContainerT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiDimContainer___ne__" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiDimContainer___ne__" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp2);
  {
    try {
      result = (bool)((gum::MultiDimContainer< double > const *)arg1)->operator !=((gum::MultiDimContainer< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_apply(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  std::function< double (double) > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MultiDimContainer_apply", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_apply" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__functionT_double_fdoubleF_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiDimContainer_apply" "', argument " "2"" of type '" "std::function< double (double) >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiDimContainer_apply" "', argument " "2"" of type '" "std::function< double (double) >""'");
    } else {
      std::function< double (double) > * temp = reinterpret_cast< std::function< double (double) > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      ((gum::MultiDimContainer< double > const *)arg1)->apply(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_reduce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  std::function< double (double,double) > arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "MultiDimContainer_reduce", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_reduce" "', argument " "1"" of type '" "gum::MultiDimContainer< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__functionT_double_fdouble_doubleF_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiDimContainer_reduce" "', argument " "2"" of type '" "std::function< double (double,double) >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiDimContainer_reduce" "', argument " "2"" of type '" "std::function< double (double,double) >""'");
    } else {
      std::function< double (double,double) > * temp = reinterpret_cast< std::function< double (double,double) > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MultiDimContainer_reduce" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (double)((gum::MultiDimContainer< double > const *)arg1)->reduce(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_beginMultipleChanges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_beginMultipleChanges" "', argument " "1"" of type '" "gum::MultiDimContainer< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  {
    try {
      (arg1)->beginMultipleChanges();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_endMultipleChanges__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_endMultipleChanges" "', argument " "1"" of type '" "gum::MultiDimContainer< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  {
    try {
      (arg1)->endMultipleChanges();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_endMultipleChanges__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimContainer< double > *arg1 = (gum::MultiDimContainer< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimContainer_endMultipleChanges" "', argument " "1"" of type '" "gum::MultiDimContainer< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MultiDimContainer_endMultipleChanges" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      (arg1)->endMultipleChanges((double const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiDimContainer_endMultipleChanges(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MultiDimContainer_endMultipleChanges", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MultiDimContainer_endMultipleChanges__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimContainerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MultiDimContainer_endMultipleChanges__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MultiDimContainer_endMultipleChanges'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MultiDimContainer< double >::endMultipleChanges()\n"
    "    gum::MultiDimContainer< double >::endMultipleChanges(double const &)\n");
  return 0;
}


SWIGINTERN PyObject *MultiDimContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__MultiDimContainerT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Potential__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (gum::Potential< double > *)new gum::Potential< double >();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Potential__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimImplementation< double > *arg1 = (gum::MultiDimImplementation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Potential" "', argument " "1"" of type '" "gum::MultiDimImplementation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimImplementation< double > * >(argp1);
  {
    try {
      result = (gum::Potential< double > *)new gum::Potential< double >(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Potential__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MultiDimImplementation< double > *arg1 = (gum::MultiDimImplementation< double > *) 0 ;
  gum::MultiDimContainer< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Potential" "', argument " "1"" of type '" "gum::MultiDimImplementation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MultiDimImplementation< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__MultiDimContainerT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Potential" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Potential" "', argument " "2"" of type '" "gum::MultiDimContainer< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::MultiDimContainer< double > * >(argp2);
  {
    try {
      result = (gum::Potential< double > *)new gum::Potential< double >(arg1,(gum::MultiDimContainer< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Potential__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Potential" "', argument " "1"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Potential" "', argument " "1"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (gum::Potential< double > *)new gum::Potential< double >((gum::Potential< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Potential__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__PotentialT_double_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Potential" "', argument " "1"" of type '" "gum::Potential< double > &&""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Potential" "', argument " "1"" of type '" "gum::Potential< double > &&""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (gum::Potential< double > *)new gum::Potential< double >((gum::Potential< double > &&)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Potential(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Potential", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Potential__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Potential__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Potential__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Potential__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__MultiDimContainerT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Potential__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Potential'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Potential< double >::Potential()\n"
    "    gum::Potential< double >::Potential(gum::MultiDimImplementation< double > *)\n"
    "    gum::Potential< double >::Potential(gum::MultiDimImplementation< double > *,gum::MultiDimContainer< double > const &)\n"
    "    gum::Potential< double >::Potential(gum::Potential< double > const &)\n"
    "    gum::Potential< double >::Potential(gum::Potential< double > &&)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Potential(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Potential" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_newFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Potential< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_newFactory" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (gum::Potential< double > *)((gum::Potential< double > const *)arg1)->newFactory();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_isNonZeroMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Potential< double > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_isNonZeroMap" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = ((gum::Potential< double > const *)arg1)->isNonZeroMap();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_sum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_sum" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (double)((gum::Potential< double > const *)arg1)->sum();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_product(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_product" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (double)((gum::Potential< double > const *)arg1)->product();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_max" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (double)((gum::Potential< double > const *)arg1)->max();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_min" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (double)((gum::Potential< double > const *)arg1)->min();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_maxNonOne(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_maxNonOne" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (double)((gum::Potential< double > const *)arg1)->maxNonOne();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_minNonZero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_minNonZero" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (double)((gum::Potential< double > const *)arg1)->minNonZero();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_findAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< gum::Set< gum::Instantiation > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_findAll", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_findAll" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Potential_findAll" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = ((gum::Potential< double > const *)arg1)->findAll(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySeqFromSetOfInstantiation(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_argmax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< gum::Set< gum::Instantiation > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_argmax" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = ((gum::Potential< double > const *)arg1)->argmax();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySeqFromSetOfInstantiation(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_argmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< gum::Set< gum::Instantiation > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_argmin" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = ((gum::Potential< double > const *)arg1)->argmin();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  {
    resultobj = PyAgrumHelper::PySeqFromSetOfInstantiation(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_entropy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_entropy" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (double)((gum::Potential< double > const *)arg1)->entropy();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_reorganize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_reorganize" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_gum__DiscreteVariable_const_p_std__allocatorT_gum__DiscreteVariable_const_p_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential_reorganize" "', argument " "2"" of type '" "std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential_reorganize" "', argument " "2"" of type '" "std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > * >(argp2);
  {
    try {
      result = ((gum::Potential< double > const *)arg1)->reorganize((std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_extract__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_extract" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential_extract" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential_extract" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      result = ((gum::Potential< double > const *)arg1)->extract((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_fillWith__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_fillWith" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential_fillWith" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential_fillWith" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = (gum::Potential< double > *) &((gum::Potential< double > const *)arg1)->fillWith((gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_fillWith__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_fillWith" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential_fillWith" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential_fillWith" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Potential_fillWith" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential_fillWith" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (gum::Potential< double > *) &((gum::Potential< double > const *)arg1)->fillWith((gum::Potential< double > const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_fillWith__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_fillWith" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential_fillWith" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential_fillWith" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Potential< double > *) &((gum::Potential< double > const *)arg1)->fillWith((std::vector< double,std::allocator< double > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_fillWith__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_fillWith" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Potential_fillWith" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  {
    try {
      result = (gum::Potential< double > *) &((gum::Potential< double > const *)arg1)->fillWith((double const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_fillWith(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Potential_fillWith", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Potential_fillWith__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Potential_fillWith__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Potential_fillWith__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Potential_fillWith__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Potential_fillWith'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Potential< double >::fillWith(gum::Potential< double > const &) const\n"
    "    gum::Potential< double >::fillWith(gum::Potential< double > const &,std::vector< std::string,std::allocator< std::string > > const &) const\n"
    "    gum::Potential< double >::fillWith(std::vector< double,std::allocator< double > > const &) const\n"
    "    gum::Potential< double >::fillWith(double const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Potential_abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Potential< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_abs" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (gum::Potential< double > *) &((gum::Potential< double > const *)arg1)->abs();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Potential< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_normalize" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (gum::Potential< double > *) &((gum::Potential< double > const *)arg1)->normalize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_sq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Potential< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_sq" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (gum::Potential< double > *) &((gum::Potential< double > const *)arg1)->sq();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_KL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_KL", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_KL" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential_KL" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential_KL" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = (double)((gum::Potential< double > const *)arg1)->KL((gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_normalizeAsCPT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_normalizeAsCPT" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      ((gum::Potential< double > const *)arg1)->normalizeAsCPT();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_scale", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_scale" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Potential_scale" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (gum::Potential< double > *) &((gum::Potential< double > const *)arg1)->scale(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_translate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_translate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_translate" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Potential_translate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (gum::Potential< double > *) &((gum::Potential< double > const *)arg1)->translate(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Idx result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_draw" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = ((gum::Potential< double > const *)arg1)->draw();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___add__" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential___add__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential___add__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = ((gum::Potential< double > const *)arg1)->operator +((gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Potential___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___sub__" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential___sub__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential___sub__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = ((gum::Potential< double > const *)arg1)->operator -((gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Potential___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential___mul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___mul__" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential___mul__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential___mul__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = ((gum::Potential< double > const *)arg1)->operator *((gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Potential___truediv____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___truediv__" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential___truediv__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential___truediv__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = ((gum::Potential< double > const *)arg1)->operator /((gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Potential___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___iadd__" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential___iadd__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential___iadd__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = (gum::Potential< double > *) &(arg1)->operator +=((gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential___imul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___imul__" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential___imul__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential___imul__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = (gum::Potential< double > *) &(arg1)->operator *=((gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___isub__" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential___isub__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential___isub__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = (gum::Potential< double > *) &(arg1)->operator -=((gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential___itruediv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential___itruediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___itruediv__" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential___itruediv__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential___itruediv__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = (gum::Potential< double > *) &(arg1)->operator /=((gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___eq__" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential___eq__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential___eq__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = (bool)((gum::Potential< double > const *)arg1)->operator ==((gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Potential___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___ne__" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential___ne__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential___ne__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = (bool)((gum::Potential< double > const *)arg1)->operator !=((gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Potential___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___repr__" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = gum_Potential_Sl_double_Sg____repr__((gum::Potential< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___str__" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = gum_Potential_Sl_double_Sg____str__((gum::Potential< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_extract__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_extract" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Potential_Sl_double_Sg__extract__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_extract(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Potential_extract", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Potential_extract__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        return _wrap_Potential_extract__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Potential_extract'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Potential< double >::extract(gum::Instantiation const &) const\n"
    "    gum::Potential< double >::extract(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Potential_reorganize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_reorganize" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Potential_Sl_double_Sg__reorganize__SWIG_1((gum::Potential< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_reorganize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Potential_reorganize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_gum__DiscreteVariable_const_p_std__allocatorT_gum__DiscreteVariable_const_p_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Potential_reorganize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        return _wrap_Potential_reorganize__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Potential_reorganize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Potential< double >::reorganize(std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > const &) const\n"
    "    gum::Potential< double >::reorganize(PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Potential_putFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_putFirst", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_putFirst" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Potential_Sl_double_Sg__putFirst((gum::Potential< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_margSumOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_margSumOut", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_margSumOut" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Potential_Sl_double_Sg__margSumOut((gum::Potential< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_margProdOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_margProdOut", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_margProdOut" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Potential_Sl_double_Sg__margProdOut((gum::Potential< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_margMaxOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_margMaxOut", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_margMaxOut" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Potential_Sl_double_Sg__margMaxOut((gum::Potential< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_margMinOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_margMinOut", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_margMinOut" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Potential_Sl_double_Sg__margMinOut((gum::Potential< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_margSumIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_margSumIn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_margSumIn" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Potential_Sl_double_Sg__margSumIn((gum::Potential< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_margProdIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_margProdIn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_margProdIn" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Potential_Sl_double_Sg__margProdIn((gum::Potential< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_margMaxIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_margMaxIn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_margMaxIn" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Potential_Sl_double_Sg__margMaxIn((gum::Potential< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_margMinIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_margMinIn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_margMinIn" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_Potential_Sl_double_Sg__margMinIn((gum::Potential< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential___truediv____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___truediv__" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential___truediv__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential___truediv__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = gum_Potential_Sl_double_Sg____truediv____SWIG_1(arg1,(gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Potential___truediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Potential___truediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Potential___truediv____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Potential___truediv____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Potential___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential___div__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___div__" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential___div__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential___div__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = gum_Potential_Sl_double_Sg____div__(arg1,(gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Potential___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___eq__" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential___eq__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential___eq__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = (bool)gum_Potential_Sl_double_Sg____eq____SWIG_1(arg1,(gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Potential___eq__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Potential___eq__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Potential___eq____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Potential___eq____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Potential___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___ne__" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential___ne__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential___ne__" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      result = (bool)gum_Potential_Sl_double_Sg____ne____SWIG_1(arg1,(gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Potential___ne__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Potential___ne__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Potential___ne____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Potential___ne____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Potential___fill_distrib__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___fill_distrib__" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      gum_Potential_Sl_double_Sg____fill_distrib__(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential___indexfromdict__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential___indexfromdict__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___indexfromdict__" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (PyObject *)gum_Potential_Sl_double_Sg____indexfromdict__(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_tolist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_tolist" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_Potential_Sl_double_Sg__tolist(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_toarray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_toarray" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_Potential_Sl_double_Sg__toarray(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___getitem__" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_Potential_Sl_double_Sg____getitem__(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential___setitem__" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      gum_Potential_Sl_double_Sg____setitem__(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_var_names(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_var_names" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      gum_Potential_Sl_double_Sg__var_names(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_var_dims(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_var_dims" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      gum_Potential_Sl_double_Sg__var_dims(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_get" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential_get" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential_get" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      result = (double)gum_Potential_Sl_double_Sg__get((gum::Potential< double > const *)arg1,(gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_set" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential_set" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential_set" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Potential_set" "', argument " "3"" of type '" "double""'");
  } 
  temp3 = static_cast< double >(val3);
  arg3 = &temp3;
  {
    try {
      gum_Potential_Sl_double_Sg__set((gum::Potential< double > const *)arg1,(gum::Instantiation const &)*arg2,(double const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_empty" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = (bool)gum_Potential_Sl_double_Sg__empty((gum::Potential< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_pos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_pos", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_pos" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential_pos" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential_pos" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = gum_Potential_Sl_double_Sg__pos((gum::Potential< double > const *)arg1,(gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_contains", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_contains" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential_contains" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential_contains" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (bool)gum_Potential_Sl_double_Sg__contains((gum::Potential< double > const *)arg1,(gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_nbrDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Idx result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_nbrDim" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    try {
      result = gum_Potential_Sl_double_Sg__nbrDim((gum::Potential< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_variable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::DiscreteVariable *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_variable" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Potential_variable" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      result = (gum::DiscreteVariable *) &gum_Potential_Sl_double_Sg__variable__SWIG_0((gum::Potential< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_variable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::DiscreteVariable *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_variable" "', argument " "1"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential_variable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential_variable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscreteVariable *) &gum_Potential_Sl_double_Sg__variable__SWIG_1((gum::Potential< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_variable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Potential_variable", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_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_Potential_variable__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__PotentialT_double_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_Potential_variable__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Potential_variable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::Potential< double >::variable(gum::Idx) const\n"
    "    gum::Potential< double >::variable(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Potential_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_remove" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential_remove" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential_remove" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      gum_Potential_Sl_double_Sg__remove(arg1,(gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Potential_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::Potential< double > *arg1 = (gum::Potential< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Potential_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Potential_add" "', argument " "1"" of type '" "gum::Potential< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::Potential< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Potential_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Potential_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      gum_Potential_Sl_double_Sg__add(arg1,(gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Potential_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__PotentialT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Potential_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_IBayesNet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IBayesNet" "', argument " "1"" of type '" "gum::IBayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_cpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_cpt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_cpt" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IBayesNet_cpt" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Potential< double > *) &((gum::IBayesNet< double > const *)arg1)->cpt(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_variableNodeMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VariableNodeMap *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_variableNodeMap" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (gum::VariableNodeMap *) &((gum::IBayesNet< double > const *)arg1)->variableNodeMap();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__VariableNodeMap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_variable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_variable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_variable" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IBayesNet_variable" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::IBayesNet< double > const *)arg1)->variable(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_nodeId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_nodeId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_nodeId" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IBayesNet_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IBayesNet_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = ((gum::IBayesNet< double > const *)arg1)->nodeId((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_idFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_idFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_idFromName" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IBayesNet_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IBayesNet_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::IBayesNet< double > const *)arg1)->idFromName((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_variableFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_variableFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_variableFromName" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IBayesNet_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IBayesNet_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::IBayesNet< double > const *)arg1)->variableFromName((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_jointProbability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_jointProbability", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_jointProbability" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IBayesNet_jointProbability" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IBayesNet_jointProbability" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      result = (double)((gum::IBayesNet< double > const *)arg1)->jointProbability((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_log2JointProbability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::Instantiation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_log2JointProbability", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_log2JointProbability" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Instantiation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IBayesNet_log2JointProbability" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IBayesNet_log2JointProbability" "', argument " "2"" of type '" "gum::Instantiation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Instantiation * >(argp2);
  {
    try {
      result = (double)((gum::IBayesNet< double > const *)arg1)->log2JointProbability((gum::Instantiation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::IBayesNet< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet___eq__" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__IBayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IBayesNet___eq__" "', argument " "2"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IBayesNet___eq__" "', argument " "2"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::IBayesNet< double > * >(argp2);
  {
    try {
      result = (bool)((gum::IBayesNet< double > const *)arg1)->operator ==((gum::IBayesNet< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_IBayesNet___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::IBayesNet< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet___ne__" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__IBayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IBayesNet___ne__" "', argument " "2"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IBayesNet___ne__" "', argument " "2"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::IBayesNet< double > * >(argp2);
  {
    try {
      result = (bool)((gum::IBayesNet< double > const *)arg1)->operator !=((gum::IBayesNet< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_IBayesNet_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_dim" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = ((gum::IBayesNet< double > const *)arg1)->dim();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_maxVarDomainSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_maxVarDomainSize" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = ((gum::IBayesNet< double > const *)arg1)->maxVarDomainSize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_minParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_minParam" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (double)((gum::IBayesNet< double > const *)arg1)->minParam();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_maxParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_maxParam" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (double)((gum::IBayesNet< double > const *)arg1)->maxParam();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_minNonZeroParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_minNonZeroParam" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (double)((gum::IBayesNet< double > const *)arg1)->minNonZeroParam();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_maxNonOneParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_maxNonOneParam" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (double)((gum::IBayesNet< double > const *)arg1)->maxNonOneParam();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_toDot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_toDot" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = ((gum::IBayesNet< double > const *)arg1)->toDot();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_minimalCondSet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeSet *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_minimalCondSet" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IBayesNet_minimalCondSet" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IBayesNet_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IBayesNet_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = ((gum::IBayesNet< double > const *)arg1)->minimalCondSet(arg2,(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(static_cast< const gum::NodeSet& >(result))), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_minimalCondSet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::NodeSet *arg2 = 0 ;
  gum::NodeSet *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SwigValueWrapper< gum::Set< std::size_t > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_minimalCondSet" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IBayesNet_minimalCondSet" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IBayesNet_minimalCondSet" "', argument " "2"" of type '" "gum::NodeSet const &""'"); 
  }
  arg2 = reinterpret_cast< gum::NodeSet * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__SetT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IBayesNet_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IBayesNet_minimalCondSet" "', argument " "3"" of type '" "gum::NodeSet const &""'"); 
  }
  arg3 = reinterpret_cast< gum::NodeSet * >(argp3);
  {
    try {
      result = ((gum::IBayesNet< double > const *)arg1)->minimalCondSet((gum::NodeSet const &)*arg2,(gum::NodeSet const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::NodeSet(static_cast< const gum::NodeSet& >(result))), SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_nodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_nodes" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_IBayesNet_Sl_double_Sg__nodes((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_names(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_names" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_IBayesNet_Sl_double_Sg__names((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_minimalCondSet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_minimalCondSet" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IBayesNet_minimalCondSet" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = (PyObject *)gum_IBayesNet_Sl_double_Sg__minimalCondSet__SWIG_2((gum::IBayesNet< double > const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_minimalCondSet__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_minimalCondSet" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = (PyObject *)gum_IBayesNet_Sl_double_Sg__minimalCondSet__SWIG_3((gum::IBayesNet< double > const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_minimalCondSet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IBayesNet_minimalCondSet", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__IBayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gum__SetT_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IBayesNet_minimalCondSet__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__IBayesNetT_double_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_gum__SetT_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IBayesNet_minimalCondSet__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__IBayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_IBayesNet_minimalCondSet__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__IBayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_IBayesNet_minimalCondSet__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IBayesNet_minimalCondSet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::IBayesNet< double >::minimalCondSet(gum::NodeId,gum::NodeSet const &) const\n"
    "    gum::IBayesNet< double >::minimalCondSet(gum::NodeSet const &,gum::NodeSet const &) const\n"
    "    gum::IBayesNet< double >::minimalCondSet(gum::NodeId,PyObject *) const\n"
    "    gum::IBayesNet< double >::minimalCondSet(PyObject *,PyObject *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IBayesNet___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet___repr__" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = gum_IBayesNet_Sl_double_Sg____repr__((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet___str__" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = gum_IBayesNet_Sl_double_Sg____str__((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_arcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_arcs" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_IBayesNet_Sl_double_Sg__arcs((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_parents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_parents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_parents" "', argument " "1"" of type '" "gum::IBayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IBayesNet_parents" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_IBayesNet_Sl_double_Sg__parents(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IBayesNet_children(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "IBayesNet_children", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IBayesNet_children" "', argument " "1"" of type '" "gum::IBayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IBayesNet_children" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_IBayesNet_Sl_double_Sg__children(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IBayesNet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__IBayesNetT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_BayesNet_fastPrototype__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  gum::Size arg2 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::BayesNet< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_fastPrototype" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_fastPrototype" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNet_fastPrototype" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = gum::BayesNet< double >::SWIGTEMPLATEDISAMBIGUATOR fastPrototype((std::string const &)*arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(static_cast< const gum::BayesNet< double >& >(result))), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_fastPrototype__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::BayesNet< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_fastPrototype" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_fastPrototype" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = gum::BayesNet< double >::SWIGTEMPLATEDISAMBIGUATOR fastPrototype((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(static_cast< const gum::BayesNet< double >& >(result))), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_fastPrototype(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_fastPrototype", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BayesNet_fastPrototype__SWIG_1(self, argc, argv);
    }
  }
  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_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BayesNet_fastPrototype__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_fastPrototype'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::fastPrototype(std::string const &,gum::Size)\n"
    "    gum::BayesNet< double >::fastPrototype(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_BayesNet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (gum::BayesNet< double > *)new gum::BayesNet< double >();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BayesNet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  gum::BayesNet< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_BayesNet" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (gum::BayesNet< double > *)new gum::BayesNet< double >(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BayesNet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BayesNet" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BayesNet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::BayesNet< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BayesNet" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BayesNet" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      result = (gum::BayesNet< double > *)new gum::BayesNet< double >((gum::BayesNet< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BayesNet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BayesNet", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_BayesNet__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BayesNet__SWIG_2(self, argc, argv);
    }
  }
  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_BayesNet__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BayesNet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::BayesNet()\n"
    "    gum::BayesNet< double >::BayesNet(std::string)\n"
    "    gum::BayesNet< double >::BayesNet(gum::BayesNet< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_cpt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_cpt" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNet_cpt" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Potential< double > *) &((gum::BayesNet< double > const *)arg1)->cpt(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_cpt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_cpt" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_cpt" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_cpt" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Potential< double > *) &((gum::BayesNet< double > const *)arg1)->cpt((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_cpt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_cpt", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_BayesNet_cpt__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_BayesNet_cpt__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_cpt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::cpt(gum::NodeId) const\n"
    "    gum::BayesNet< double >::cpt(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_variableNodeMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::VariableNodeMap *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_variableNodeMap" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      result = (gum::VariableNodeMap *) &((gum::BayesNet< double > const *)arg1)->variableNodeMap();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__VariableNodeMap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_add" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (arg1)->add((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_add" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_add" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (arg1)->add((std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_add__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::MultiDimImplementation< double > *arg3 = (gum::MultiDimImplementation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_add" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNet_add" "', argument " "3"" of type '" "gum::MultiDimImplementation< double > *""'"); 
  }
  arg3 = reinterpret_cast< gum::MultiDimImplementation< double > * >(argp3);
  {
    try {
      result = (arg1)->add((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_add__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_add" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_add" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (arg1)->add((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_add__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::MultiDimImplementation< double > *arg3 = (gum::MultiDimImplementation< double > *) 0 ;
  gum::NodeId arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_add" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNet_add" "', argument " "3"" of type '" "gum::MultiDimImplementation< double > *""'"); 
  }
  arg3 = reinterpret_cast< gum::MultiDimImplementation< double > * >(argp3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BayesNet_add" "', argument " "4"" of type '" "gum::NodeId""'");
  } 
  arg4 = static_cast< gum::NodeId >(val4);
  {
    try {
      result = (arg1)->add((gum::DiscreteVariable const &)*arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_add", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BayesNet_add__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNet_add__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNet_add__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNet_add__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BayesNet_add__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::add(gum::DiscreteVariable const &)\n"
    "    gum::BayesNet< double >::add(std::string const &,unsigned int)\n"
    "    gum::BayesNet< double >::add(gum::DiscreteVariable const &,gum::MultiDimImplementation< double > *)\n"
    "    gum::BayesNet< double >::add(gum::DiscreteVariable const &,gum::NodeId)\n"
    "    gum::BayesNet< double >::add(gum::DiscreteVariable const &,gum::MultiDimImplementation< double > *,gum::NodeId)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_erase" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNet_erase" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      (arg1)->erase(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_erase" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_erase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_erase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->erase((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_erase" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_erase" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_erase" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      (arg1)->erase((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_erase", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BayesNet_erase__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_BayesNet_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_BayesNet_erase__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::erase(gum::NodeId)\n"
    "    gum::BayesNet< double >::erase(std::string const &)\n"
    "    gum::BayesNet< double >::erase(gum::DiscreteVariable const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_variable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::DiscreteVariable *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_variable" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNet_variable" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::BayesNet< double > const *)arg1)->variable(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_variable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::DiscreteVariable *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_variable" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_variable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_variable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::BayesNet< double > const *)arg1)->variable((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_variable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_variable", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_BayesNet_variable__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_BayesNet_variable__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_variable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::variable(gum::NodeId) const\n"
    "    gum::BayesNet< double >::variable(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_changeVariableName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_changeVariableName" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNet_changeVariableName" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNet_changeVariableName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_changeVariableName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->changeVariableName(arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_changeVariableName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_changeVariableName" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_changeVariableName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_changeVariableName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNet_changeVariableName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_changeVariableName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->changeVariableName((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_changeVariableName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_changeVariableName", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNet_changeVariableName__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNet_changeVariableName__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_changeVariableName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::changeVariableName(gum::NodeId,std::string const &)\n"
    "    gum::BayesNet< double >::changeVariableName(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_changeVariableLabel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_changeVariableLabel" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNet_changeVariableLabel" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNet_changeVariableLabel" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_changeVariableLabel" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BayesNet_changeVariableLabel" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_changeVariableLabel" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      (arg1)->changeVariableLabel(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_changeVariableLabel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_changeVariableLabel" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_changeVariableLabel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_changeVariableLabel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNet_changeVariableLabel" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_changeVariableLabel" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BayesNet_changeVariableLabel" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_changeVariableLabel" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      (arg1)->changeVariableLabel((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_changeVariableLabel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_changeVariableLabel", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_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_BayesNet_changeVariableLabel__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_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_BayesNet_changeVariableLabel__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_changeVariableLabel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::changeVariableLabel(gum::NodeId,std::string const &,std::string const &)\n"
    "    gum::BayesNet< double >::changeVariableLabel(std::string const &,std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_nodeId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_nodeId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_nodeId" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = ((gum::BayesNet< double > const *)arg1)->nodeId((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_idFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_idFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_idFromName" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::BayesNet< double > const *)arg1)->idFromName((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_variableFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_variableFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_variableFromName" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::BayesNet< double > const *)arg1)->variableFromName((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addArc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addArc" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNet_addArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_addArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->addArc(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addArc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addArc" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNet_addArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->addArc((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_addArc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNet_addArc__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNet_addArc__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_addArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::addArc(gum::NodeId,gum::NodeId)\n"
    "    gum::BayesNet< double >::addArc(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_eraseArc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_eraseArc" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Arc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_eraseArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_eraseArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Arc * >(argp2);
  {
    try {
      (arg1)->eraseArc((gum::Arc const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_eraseArc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_eraseArc" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNet_eraseArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_eraseArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->eraseArc(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_eraseArc__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_eraseArc" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_eraseArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_eraseArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNet_eraseArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_eraseArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->eraseArc((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_eraseArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_eraseArc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__Arc, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BayesNet_eraseArc__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNet_eraseArc__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNet_eraseArc__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_eraseArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::eraseArc(gum::Arc const &)\n"
    "    gum::BayesNet< double >::eraseArc(gum::NodeId,gum::NodeId)\n"
    "    gum::BayesNet< double >::eraseArc(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_beginTopologyTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_beginTopologyTransformation" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      (arg1)->beginTopologyTransformation();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_endTopologyTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_endTopologyTransformation" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      (arg1)->endTopologyTransformation();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_reverseArc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_reverseArc" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNet_reverseArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_reverseArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->reverseArc(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_reverseArc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_reverseArc" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_reverseArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_reverseArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNet_reverseArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_reverseArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->reverseArc((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_reverseArc__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_reverseArc" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Arc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_reverseArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_reverseArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Arc * >(argp2);
  {
    try {
      (arg1)->reverseArc((gum::Arc const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_reverseArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_reverseArc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__Arc, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BayesNet_reverseArc__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNet_reverseArc__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNet_reverseArc__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_reverseArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::reverseArc(gum::NodeId,gum::NodeId)\n"
    "    gum::BayesNet< double >::reverseArc(std::string const &,std::string const &)\n"
    "    gum::BayesNet< double >::reverseArc(gum::Arc const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_addNoisyOR__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addNoisyOR" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addNoisyOR" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addNoisyOR" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_addNoisyOR" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (arg1)->addNoisyOR((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addNoisyORNet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addNoisyORNet" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addNoisyORNet" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addNoisyORNet" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_addNoisyORNet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (arg1)->addNoisyORNet((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addNoisyORCompound__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addNoisyORCompound" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addNoisyORCompound" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addNoisyORCompound" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_addNoisyORCompound" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (arg1)->addNoisyORCompound((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addNoisyOR__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  double arg3 ;
  gum::NodeId arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addNoisyOR" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addNoisyOR" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addNoisyOR" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_addNoisyOR" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BayesNet_addNoisyOR" "', argument " "4"" of type '" "gum::NodeId""'");
  } 
  arg4 = static_cast< gum::NodeId >(val4);
  {
    try {
      result = (arg1)->addNoisyOR((gum::DiscreteVariable const &)*arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addNoisyOR(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_addNoisyOR", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNet_addNoisyOR__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 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_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BayesNet_addNoisyOR__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_addNoisyOR'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::addNoisyOR(gum::DiscreteVariable const &,double)\n"
    "    gum::BayesNet< double >::addNoisyOR(gum::DiscreteVariable const &,double,gum::NodeId)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_addNoisyORNet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  double arg3 ;
  gum::NodeId arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addNoisyORNet" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addNoisyORNet" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addNoisyORNet" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_addNoisyORNet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BayesNet_addNoisyORNet" "', argument " "4"" of type '" "gum::NodeId""'");
  } 
  arg4 = static_cast< gum::NodeId >(val4);
  {
    try {
      result = (arg1)->addNoisyORNet((gum::DiscreteVariable const &)*arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addNoisyORNet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_addNoisyORNet", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNet_addNoisyORNet__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 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_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BayesNet_addNoisyORNet__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_addNoisyORNet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::addNoisyORNet(gum::DiscreteVariable const &,double)\n"
    "    gum::BayesNet< double >::addNoisyORNet(gum::DiscreteVariable const &,double,gum::NodeId)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_addNoisyORCompound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  double arg3 ;
  gum::NodeId arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addNoisyORCompound" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addNoisyORCompound" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addNoisyORCompound" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_addNoisyORCompound" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BayesNet_addNoisyORCompound" "', argument " "4"" of type '" "gum::NodeId""'");
  } 
  arg4 = static_cast< gum::NodeId >(val4);
  {
    try {
      result = (arg1)->addNoisyORCompound((gum::DiscreteVariable const &)*arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addNoisyORCompound(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_addNoisyORCompound", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNet_addNoisyORCompound__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 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_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BayesNet_addNoisyORCompound__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_addNoisyORCompound'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::addNoisyORCompound(gum::DiscreteVariable const &,double)\n"
    "    gum::BayesNet< double >::addNoisyORCompound(gum::DiscreteVariable const &,double,gum::NodeId)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_addNoisyAND__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  double arg3 ;
  gum::NodeId arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addNoisyAND" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addNoisyAND" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addNoisyAND" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_addNoisyAND" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BayesNet_addNoisyAND" "', argument " "4"" of type '" "gum::NodeId""'");
  } 
  arg4 = static_cast< gum::NodeId >(val4);
  {
    try {
      result = (arg1)->addNoisyAND((gum::DiscreteVariable const &)*arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addNoisyAND__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addNoisyAND" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addNoisyAND" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addNoisyAND" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_addNoisyAND" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (arg1)->addNoisyAND((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addNoisyAND(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_addNoisyAND", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNet_addNoisyAND__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 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_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BayesNet_addNoisyAND__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_addNoisyAND'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::addNoisyAND(gum::DiscreteVariable const &,double,gum::NodeId)\n"
    "    gum::BayesNet< double >::addNoisyAND(gum::DiscreteVariable const &,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_addLogit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  double arg3 ;
  gum::NodeId arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addLogit" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addLogit" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addLogit" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_addLogit" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BayesNet_addLogit" "', argument " "4"" of type '" "gum::NodeId""'");
  } 
  arg4 = static_cast< gum::NodeId >(val4);
  {
    try {
      result = (arg1)->addLogit((gum::DiscreteVariable const &)*arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addLogit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addLogit" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addLogit" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addLogit" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_addLogit" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (arg1)->addLogit((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addLogit(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_addLogit", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNet_addLogit__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 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_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BayesNet_addLogit__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_addLogit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::addLogit(gum::DiscreteVariable const &,double,gum::NodeId)\n"
    "    gum::BayesNet< double >::addLogit(gum::DiscreteVariable const &,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_addOR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_addOR", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addOR" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addOR" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addOR" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (arg1)->addOR((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addAND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_addAND", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addAND" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addAND" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addAND" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (arg1)->addAND((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addAMPLITUDE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_addAMPLITUDE", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addAMPLITUDE" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addAMPLITUDE" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addAMPLITUDE" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (arg1)->addAMPLITUDE((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addCOUNT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addCOUNT" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addCOUNT" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addCOUNT" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_addCOUNT" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      result = (arg1)->addCOUNT((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addCOUNT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addCOUNT" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addCOUNT" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addCOUNT" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (arg1)->addCOUNT((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addCOUNT(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_addCOUNT", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BayesNet_addCOUNT__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNet_addCOUNT__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_addCOUNT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::addCOUNT(gum::DiscreteVariable const &,gum::Idx)\n"
    "    gum::BayesNet< double >::addCOUNT(gum::DiscreteVariable const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_addEXISTS__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addEXISTS" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addEXISTS" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addEXISTS" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_addEXISTS" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      result = (arg1)->addEXISTS((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addEXISTS__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addEXISTS" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addEXISTS" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addEXISTS" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (arg1)->addEXISTS((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addEXISTS(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_addEXISTS", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BayesNet_addEXISTS__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNet_addEXISTS__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_addEXISTS'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::addEXISTS(gum::DiscreteVariable const &,gum::Idx)\n"
    "    gum::BayesNet< double >::addEXISTS(gum::DiscreteVariable const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_addFORALL__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addFORALL" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addFORALL" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addFORALL" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_addFORALL" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      result = (arg1)->addFORALL((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addFORALL__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addFORALL" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addFORALL" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addFORALL" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (arg1)->addFORALL((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addFORALL(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_addFORALL", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BayesNet_addFORALL__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNet_addFORALL__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_addFORALL'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::addFORALL(gum::DiscreteVariable const &,gum::Idx)\n"
    "    gum::BayesNet< double >::addFORALL(gum::DiscreteVariable const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_addMAX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_addMAX", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addMAX" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addMAX" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addMAX" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (arg1)->addMAX((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addMEDIAN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_addMEDIAN", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addMEDIAN" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addMEDIAN" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addMEDIAN" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (arg1)->addMEDIAN((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addMIN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_addMIN", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addMIN" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addMIN" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addMIN" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (arg1)->addMIN((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addWeightedArc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addWeightedArc" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNet_addWeightedArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNet_addWeightedArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BayesNet_addWeightedArc" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    try {
      (arg1)->addWeightedArc(arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addWeightedArc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_addWeightedArc" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_addWeightedArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addWeightedArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNet_addWeightedArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_addWeightedArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BayesNet_addWeightedArc" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    try {
      (arg1)->addWeightedArc((std::string const &)*arg2,(std::string const &)*arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_addWeightedArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_addWeightedArc", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_AsVal_size_t(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_BayesNet_addWeightedArc__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_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_BayesNet_addWeightedArc__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_addWeightedArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::addWeightedArc(gum::NodeId,gum::NodeId,double)\n"
    "    gum::BayesNet< double >::addWeightedArc(std::string const &,std::string const &,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_generateCPTs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_generateCPTs" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      ((gum::BayesNet< double > const *)arg1)->generateCPTs();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_generateCPT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_generateCPT" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNet_generateCPT" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      ((gum::BayesNet< double > const *)arg1)->generateCPT(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_generateCPT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_generateCPT" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_generateCPT" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_generateCPT" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      ((gum::BayesNet< double > const *)arg1)->generateCPT((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_generateCPT(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_generateCPT", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_BayesNet_generateCPT__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_BayesNet_generateCPT__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_generateCPT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::generateCPT(gum::NodeId) const\n"
    "    gum::BayesNet< double >::generateCPT(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_changePotential__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Potential< double > *arg3 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_changePotential" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNet_changePotential" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNet_changePotential" "', argument " "3"" of type '" "gum::Potential< double > *""'"); 
  }
  arg3 = reinterpret_cast< gum::Potential< double > * >(argp3);
  {
    try {
      (arg1)->changePotential(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_changePotential__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Potential< double > *arg3 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_changePotential" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNet_changePotential" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNet_changePotential" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNet_changePotential" "', argument " "3"" of type '" "gum::Potential< double > *""'"); 
  }
  arg3 = reinterpret_cast< gum::Potential< double > * >(argp3);
  {
    try {
      (arg1)->changePotential((std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_changePotential(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_changePotential", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNet_changePotential__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNet_changePotential__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_changePotential'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::changePotential(gum::NodeId,gum::Potential< double > *)\n"
    "    gum::BayesNet< double >::changePotential(std::string const &,gum::Potential< double > *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_dag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DAG *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_dag" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      result = (gum::DAG *) &((gum::BayesNet< double > const *)arg1)->dag();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DAG, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_size" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      result = ((gum::BayesNet< double > const *)arg1)->size();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_nodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_nodes" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_BayesNet_Sl_double_Sg__nodes((gum::BayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_log10DomainSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_log10DomainSize" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      result = (double)((gum::BayesNet< double > const *)arg1)->log10DomainSize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadBIF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_loadBIF" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadBIF" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  arg3 = swig_obj[2];
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__loadBIF__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadBIF__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_loadBIF" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadBIF" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__loadBIF__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadBIF(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_loadBIF", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_BayesNet_loadBIF__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_BayesNet_loadBIF__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_loadBIF'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::loadBIF(std::string,PyObject *)\n"
    "    gum::BayesNet< double >::loadBIF(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveBIF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_saveBIF", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_saveBIF" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_saveBIF" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveBIF(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadDSL__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_loadDSL" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadDSL" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  arg3 = swig_obj[2];
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__loadDSL__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadDSL__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_loadDSL" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadDSL" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__loadDSL__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadDSL(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_loadDSL", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_BayesNet_loadDSL__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_BayesNet_loadDSL__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_loadDSL'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::loadDSL(std::string,PyObject *)\n"
    "    gum::BayesNet< double >::loadDSL(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveDSL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_saveDSL", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_saveDSL" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_saveDSL" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveDSL(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadNET__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_loadNET" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadNET" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  arg3 = swig_obj[2];
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__loadNET__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadNET__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_loadNET" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadNET" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__loadNET__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadNET(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_loadNET", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_BayesNet_loadNET__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_BayesNet_loadNET__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_loadNET'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::loadNET(std::string,PyObject *)\n"
    "    gum::BayesNet< double >::loadNET(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveNET(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_saveNET", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_saveNET" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_saveNET" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveNET(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadO3PRM__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  PyObject *arg5 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_loadO3PRM" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadO3PRM" "', 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(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadO3PRM" "', 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(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadO3PRM" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  arg5 = swig_obj[4];
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__loadO3PRM__SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadO3PRM__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_loadO3PRM" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadO3PRM" "', 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(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadO3PRM" "', 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(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadO3PRM" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__loadO3PRM__SWIG_0(arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadO3PRM__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_loadO3PRM" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadO3PRM" "', 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(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadO3PRM" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__loadO3PRM__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadO3PRM__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_loadO3PRM" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadO3PRM" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__loadO3PRM__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadO3PRM(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_loadO3PRM", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_BayesNet_loadO3PRM__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNet_loadO3PRM__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_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_BayesNet_loadO3PRM__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_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) {
            _v = (argv[4] != 0);
            if (_v) {
              return _wrap_BayesNet_loadO3PRM__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_loadO3PRM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::loadO3PRM(std::string,std::string,std::string,PyObject *)\n"
    "    gum::BayesNet< double >::loadO3PRM(std::string,std::string,std::string)\n"
    "    gum::BayesNet< double >::loadO3PRM(std::string,std::string)\n"
    "    gum::BayesNet< double >::loadO3PRM(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveO3PRM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_saveO3PRM", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_saveO3PRM" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_saveO3PRM" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveO3PRM(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadBIFXML__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_loadBIFXML" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadBIFXML" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  arg3 = swig_obj[2];
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__loadBIFXML__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadBIFXML__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_loadBIFXML" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadBIFXML" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__loadBIFXML__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadBIFXML(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_loadBIFXML", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_BayesNet_loadBIFXML__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_BayesNet_loadBIFXML__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_loadBIFXML'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::loadBIFXML(std::string,PyObject *)\n"
    "    gum::BayesNet< double >::loadBIFXML(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveBIFXML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_saveBIFXML", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_saveBIFXML" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_saveBIFXML" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveBIFXML(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadUAI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_loadUAI" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadUAI" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  arg3 = swig_obj[2];
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__loadUAI__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadUAI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_loadUAI" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_loadUAI" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_BayesNet_Sl_double_Sg__loadUAI__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet_loadUAI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNet_loadUAI", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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_BayesNet_loadUAI__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetT_double_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) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_BayesNet_loadUAI__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNet_loadUAI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNet< double >::loadUAI(std::string,PyObject *)\n"
    "    gum::BayesNet< double >::loadUAI(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNet_saveUAI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNet_saveUAI", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet_saveUAI" "', argument " "1"" of type '" "gum::BayesNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BayesNet_saveUAI" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      gum_BayesNet_Sl_double_Sg__saveUAI(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet___repr__" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      result = gum_BayesNet_Sl_double_Sg____repr__((gum::BayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNet___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = (gum::BayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNet___str__" "', argument " "1"" of type '" "gum::BayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      result = gum_BayesNet_Sl_double_Sg____str__((gum::BayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BayesNet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BayesNet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_BayesNetInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BayesNetInference" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_setBN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::IBayesNet< double > *arg2 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNetInference_setBN", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_setBN" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_setBN" "', argument " "2"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg2 = reinterpret_cast< gum::IBayesNet< double > * >(argp2);
  {
    try {
      (arg1)->setBN((gum::IBayesNet< double > const *)arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_BN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_BN" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = (gum::IBayesNet< double > *) &((gum::BayesNetInference< double > const *)arg1)->BN();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_domainSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeProperty< gum::Size > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_domainSizes" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = (gum::NodeProperty< gum::Size > *) &((gum::BayesNetInference< double > const *)arg1)->domainSizes();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NodePropertyT_std__size_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_isInferenceReady(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_isInferenceReady" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = (bool)((gum::BayesNetInference< double > const *)arg1)->isInferenceReady();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_isInferenceOutdatedBNStructure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_isInferenceOutdatedBNStructure" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = (bool)((gum::BayesNetInference< double > const *)arg1)->isInferenceOutdatedBNStructure();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_isInferenceOutdatedBNPotentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_isInferenceOutdatedBNPotentials" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = (bool)((gum::BayesNetInference< double > const *)arg1)->isInferenceOutdatedBNPotentials();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_isInferenceDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_isInferenceDone" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = (bool)((gum::BayesNetInference< double > const *)arg1)->isInferenceDone();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_isDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_isDone" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = (bool)((gum::BayesNetInference< double > const *)arg1)->isDone();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_prepareInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_prepareInference" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      (arg1)->prepareInference();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_makeInference" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      (arg1)->makeInference();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_clear" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_state(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::BayesNetInference< double >::StateOfInference result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_state" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = (gum::BayesNetInference< double >::StateOfInference)((gum::BayesNetInference< double > const *)arg1)->state();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_addEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_addEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetInference_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNetInference_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      (arg1)->addEvidence(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_addEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_addEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNetInference_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      (arg1)->addEvidence((std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_addEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_addEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetInference_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNetInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->addEvidence(arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_addEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_addEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNetInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->addEvidence((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_addEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_addEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetInference_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNetInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->addEvidence(arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_addEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_addEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNetInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->addEvidence((std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_addEvidence__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_addEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_addEvidence" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_addEvidence" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      (arg1)->addEvidence((gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_addEvidence__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_addEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_addEvidence" "', argument " "2"" of type '" "gum::Potential< double > &&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_addEvidence" "', argument " "2"" of type '" "gum::Potential< double > &&""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      (arg1)->addEvidence((gum::Potential< double > &&)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetInference_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BayesNetInference_addEvidence__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BayesNetInference_addEvidence__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNetInference_addEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNetInference_addEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNetInference_addEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNetInference_addEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNetInference_addEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNetInference_addEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetInference_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetInference< double >::addEvidence(gum::NodeId,gum::Idx const)\n"
    "    gum::BayesNetInference< double >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::BayesNetInference< double >::addEvidence(gum::NodeId,std::string const &)\n"
    "    gum::BayesNetInference< double >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::BayesNetInference< double >::addEvidence(gum::NodeId,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::BayesNetInference< double >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::BayesNetInference< double >::addEvidence(gum::Potential< double > const &)\n"
    "    gum::BayesNetInference< double >::addEvidence(gum::Potential< double > &&)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_addSetOfEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::Set< gum::Potential< double > const * > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNetInference_addSetOfEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_addSetOfEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__SetT_gum__PotentialT_double_t_const_p_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_addSetOfEvidence" "', argument " "2"" of type '" "gum::Set< gum::Potential< double > const * > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_addSetOfEvidence" "', argument " "2"" of type '" "gum::Set< gum::Potential< double > const * > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Set< gum::Potential< double > const * > * >(argp2);
  {
    try {
      (arg1)->addSetOfEvidence((gum::Set< gum::Potential< double > const * > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_addListOfEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::List< gum::Potential< double > const * > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BayesNetInference_addListOfEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_addListOfEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__ListT_gum__PotentialT_double_t_const_p_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_addListOfEvidence" "', argument " "2"" of type '" "gum::List< gum::Potential< double > const * > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_addListOfEvidence" "', argument " "2"" of type '" "gum::List< gum::Potential< double > const * > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::List< gum::Potential< double > const * > * >(argp2);
  {
    try {
      (arg1)->addListOfEvidence((gum::List< gum::Potential< double > const * > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_chgEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_chgEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetInference_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNetInference_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      (arg1)->chgEvidence(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_chgEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_chgEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BayesNetInference_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      (arg1)->chgEvidence((std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_chgEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_chgEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetInference_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNetInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->chgEvidence(arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_chgEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_chgEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNetInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->chgEvidence((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_chgEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_chgEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetInference_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNetInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->chgEvidence(arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_chgEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_chgEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BayesNetInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->chgEvidence((std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_chgEvidence__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::Potential< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_chgEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__PotentialT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_chgEvidence" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_chgEvidence" "', argument " "2"" of type '" "gum::Potential< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      (arg1)->chgEvidence((gum::Potential< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_chgEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetInference_chgEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BayesNetInference_chgEvidence__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNetInference_chgEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNetInference_chgEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNetInference_chgEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BayesNetInference_chgEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNetInference_chgEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BayesNetInference_chgEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetInference_chgEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetInference< double >::chgEvidence(gum::NodeId,gum::Idx const)\n"
    "    gum::BayesNetInference< double >::chgEvidence(std::string const &,gum::Idx const)\n"
    "    gum::BayesNetInference< double >::chgEvidence(gum::NodeId,std::string const &)\n"
    "    gum::BayesNetInference< double >::chgEvidence(std::string const &,std::string const &)\n"
    "    gum::BayesNetInference< double >::chgEvidence(gum::NodeId,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::BayesNetInference< double >::chgEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::BayesNetInference< double >::chgEvidence(gum::Potential< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_eraseAllEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_eraseAllEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      (arg1)->eraseAllEvidence();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_eraseEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_eraseEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetInference_eraseEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      (arg1)->eraseEvidence(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_eraseEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_eraseEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->eraseEvidence((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_eraseEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetInference_eraseEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_BayesNetInference_eraseEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_BayesNetInference_eraseEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetInference_eraseEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetInference< double >::eraseEvidence(gum::NodeId)\n"
    "    gum::BayesNetInference< double >::eraseEvidence(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_hasEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_hasEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = (bool)((gum::BayesNetInference< double > const *)arg1)->hasEvidence();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_hasEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_hasEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetInference_hasEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)((gum::BayesNetInference< double > const *)arg1)->hasEvidence(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_hasHardEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_hasHardEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetInference_hasHardEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)((gum::BayesNetInference< double > const *)arg1)->hasHardEvidence(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_hasSoftEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_hasSoftEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BayesNetInference_hasSoftEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)((gum::BayesNetInference< double > const *)arg1)->hasSoftEvidence(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_hasEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_hasEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)((gum::BayesNetInference< double > const *)arg1)->hasEvidence((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_hasEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetInference_hasEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BayesNetInference_hasEvidence__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_BayesNetInference_hasEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_BayesNetInference_hasEvidence__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetInference_hasEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetInference< double >::hasEvidence() const\n"
    "    gum::BayesNetInference< double >::hasEvidence(gum::NodeId) const\n"
    "    gum::BayesNetInference< double >::hasEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_hasHardEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_hasHardEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)((gum::BayesNetInference< double > const *)arg1)->hasHardEvidence((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_hasHardEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetInference_hasHardEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_BayesNetInference_hasHardEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_BayesNetInference_hasHardEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetInference_hasHardEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetInference< double >::hasHardEvidence(gum::NodeId) const\n"
    "    gum::BayesNetInference< double >::hasHardEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_hasSoftEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_hasSoftEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BayesNetInference_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BayesNetInference_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)((gum::BayesNetInference< double > const *)arg1)->hasSoftEvidence((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_hasSoftEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BayesNetInference_hasSoftEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_BayesNetInference_hasSoftEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__BayesNetInferenceT_double_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_BayesNetInference_hasSoftEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BayesNetInference_hasSoftEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::BayesNetInference< double >::hasSoftEvidence(gum::NodeId) const\n"
    "    gum::BayesNetInference< double >::hasSoftEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_nbrEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_nbrEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = ((gum::BayesNetInference< double > const *)arg1)->nbrEvidence();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_nbrHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_nbrHardEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = ((gum::BayesNetInference< double > const *)arg1)->nbrHardEvidence();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_nbrSoftEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_nbrSoftEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = ((gum::BayesNetInference< double > const *)arg1)->nbrSoftEvidence();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_evidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeProperty< gum::Potential< double > const * > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_evidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = (gum::NodeProperty< gum::Potential< double > const * > *) &((gum::BayesNetInference< double > const *)arg1)->evidence();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NodePropertyT_gum__PotentialT_double_t_const_p_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_softEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeSet *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_softEvidenceNodes" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = (gum::NodeSet *) &((gum::BayesNetInference< double > const *)arg1)->softEvidenceNodes();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SetT_std__size_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_hardEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeSet *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_hardEvidenceNodes" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = (gum::NodeSet *) &((gum::BayesNetInference< double > const *)arg1)->hardEvidenceNodes();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__SetT_std__size_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BayesNetInference_hardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNetInference< double > *arg1 = (gum::BayesNetInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeProperty< gum::Idx > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__BayesNetInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BayesNetInference_hardEvidence" "', argument " "1"" of type '" "gum::BayesNetInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNetInference< double > * >(argp1);
  {
    try {
      result = (gum::NodeProperty< gum::Idx > *) &((gum::BayesNetInference< double > const *)arg1)->hardEvidence();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NodePropertyT_std__size_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BayesNetInference_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__BayesNetInferenceT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LazyPropagation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::RelevantPotentialsFinderType arg2 ;
  gum::FindBarrenNodesType arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  gum::LazyPropagation< double > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LazyPropagation" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LazyPropagation" "', argument " "2"" of type '" "gum::RelevantPotentialsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantPotentialsFinderType >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LazyPropagation" "', argument " "3"" of type '" "gum::FindBarrenNodesType""'");
  } 
  arg3 = static_cast< gum::FindBarrenNodesType >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LazyPropagation" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (gum::LazyPropagation< double > *)new gum::LazyPropagation< double >((gum::IBayesNet< double > const *)arg1,arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LazyPropagationT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LazyPropagation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::RelevantPotentialsFinderType arg2 ;
  gum::FindBarrenNodesType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  gum::LazyPropagation< double > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LazyPropagation" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LazyPropagation" "', argument " "2"" of type '" "gum::RelevantPotentialsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantPotentialsFinderType >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LazyPropagation" "', argument " "3"" of type '" "gum::FindBarrenNodesType""'");
  } 
  arg3 = static_cast< gum::FindBarrenNodesType >(val3);
  {
    try {
      result = (gum::LazyPropagation< double > *)new gum::LazyPropagation< double >((gum::IBayesNet< double > const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LazyPropagationT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LazyPropagation__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::RelevantPotentialsFinderType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  gum::LazyPropagation< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LazyPropagation" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LazyPropagation" "', argument " "2"" of type '" "gum::RelevantPotentialsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantPotentialsFinderType >(val2);
  {
    try {
      result = (gum::LazyPropagation< double > *)new gum::LazyPropagation< double >((gum::IBayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LazyPropagationT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LazyPropagation__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::LazyPropagation< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LazyPropagation" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (gum::LazyPropagation< double > *)new gum::LazyPropagation< double >((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LazyPropagationT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LazyPropagation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LazyPropagation", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__IBayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LazyPropagation__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__IBayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LazyPropagation__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__IBayesNetT_double_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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_LazyPropagation__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__IBayesNetT_double_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_AsVal_int(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_new_LazyPropagation__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LazyPropagation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LazyPropagation< double >::LazyPropagation(gum::IBayesNet< double > const *,gum::RelevantPotentialsFinderType,gum::FindBarrenNodesType,bool)\n"
    "    gum::LazyPropagation< double >::LazyPropagation(gum::IBayesNet< double > const *,gum::RelevantPotentialsFinderType,gum::FindBarrenNodesType)\n"
    "    gum::LazyPropagation< double >::LazyPropagation(gum::IBayesNet< double > const *,gum::RelevantPotentialsFinderType)\n"
    "    gum::LazyPropagation< double >::LazyPropagation(gum::IBayesNet< double > const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LazyPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LazyPropagation" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_setTriangulation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::Triangulation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_setTriangulation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_setTriangulation" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Triangulation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_setTriangulation" "', argument " "2"" of type '" "gum::Triangulation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_setTriangulation" "', argument " "2"" of type '" "gum::Triangulation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Triangulation * >(argp2);
  {
    try {
      (arg1)->setTriangulation((gum::Triangulation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_setRelevantPotentialsFinderType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::RelevantPotentialsFinderType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_setRelevantPotentialsFinderType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_setRelevantPotentialsFinderType" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_setRelevantPotentialsFinderType" "', argument " "2"" of type '" "gum::RelevantPotentialsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantPotentialsFinderType >(val2);
  {
    try {
      (arg1)->setRelevantPotentialsFinderType(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_setFindBarrenNodesType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::FindBarrenNodesType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_setFindBarrenNodesType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_setFindBarrenNodesType" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_setFindBarrenNodesType" "', argument " "2"" of type '" "gum::FindBarrenNodesType""'");
  } 
  arg2 = static_cast< gum::FindBarrenNodesType >(val2);
  {
    try {
      (arg1)->setFindBarrenNodesType(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_joinTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::JoinTree *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_joinTree" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = (gum::JoinTree *)(arg1)->joinTree();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_junctionTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::JunctionTree *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_junctionTree" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = (gum::JunctionTree *)(arg1)->junctionTree();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_evidenceProbability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_evidenceProbability" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = (double)(arg1)->evidenceProbability();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_setEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_setEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_updateEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_updateEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_updateEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__updateEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_setTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_setTargets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_setTargets" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__setTargets(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_hardEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_hardEvidenceNodes" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LazyPropagation_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_softEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_softEvidenceNodes" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LazyPropagation_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_targets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_targets" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LazyPropagation_Sl_double_Sg__targets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_evidenceImpact__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_evidenceImpact" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_evidenceImpact" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_jointMutualInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_jointMutualInformation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_jointMutualInformation" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (double)gum_LazyPropagation_Sl_double_Sg__jointMutualInformation(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_evidenceJointImpact__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_evidenceJointImpact" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__evidenceJointImpact__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_jointPosterior(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_jointPosterior", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_jointPosterior" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__jointPosterior(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addJointTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_addJointTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_addJointTarget" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__addJointTarget(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_eraseJointTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_eraseJointTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_eraseJointTarget" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__eraseJointTarget(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_isJointTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_isJointTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_isJointTarget" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (bool)gum_LazyPropagation_Sl_double_Sg__isJointTarget(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_jointTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_jointTargets" "', argument " "1"" of type '" "gum::LazyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LazyPropagation_Sl_double_Sg__jointTargets((gum::LazyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_makeInference" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__makeInference(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_posterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_posterior" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_posterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__posterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_posterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_posterior" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LazyPropagation_posterior" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__posterior__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_posterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LazyPropagation_posterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_posterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_posterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LazyPropagation_posterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LazyPropagation< double >::posterior(gum::NodeId const)\n"
    "    gum::LazyPropagation< double >::posterior(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_BN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_BN" "', argument " "1"" of type '" "gum::LazyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = (gum::IBayesNet< double > *) &gum_LazyPropagation_Sl_double_Sg__BN((gum::LazyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_addEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LazyPropagation_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__addEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_addEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LazyPropagation_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_addEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LazyPropagation_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__addEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_addEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LazyPropagation_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__addEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_addEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LazyPropagation_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__addEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_addEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LazyPropagation_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__addEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LazyPropagation_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LazyPropagation_addEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LazyPropagation_addEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LazyPropagation_addEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LazyPropagation_addEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LazyPropagation_addEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LazyPropagation_addEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LazyPropagation_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LazyPropagation< double >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::LazyPropagation< double >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::LazyPropagation< double >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::LazyPropagation< double >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::LazyPropagation< double >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::LazyPropagation< double >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_chgEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_chgEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LazyPropagation_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_chgEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_chgEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LazyPropagation_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_chgEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_chgEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LazyPropagation_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_chgEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_chgEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LazyPropagation_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_chgEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_chgEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LazyPropagation_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_chgEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_chgEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LazyPropagation_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__chgEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_chgEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LazyPropagation_chgEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LazyPropagation_chgEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LazyPropagation_chgEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LazyPropagation_chgEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LazyPropagation_chgEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LazyPropagation_chgEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LazyPropagation_chgEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LazyPropagation_chgEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LazyPropagation< double >::chgEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::LazyPropagation< double >::chgEvidence(std::string const &,gum::Idx const)\n"
    "    gum::LazyPropagation< double >::chgEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::LazyPropagation< double >::chgEvidence(std::string const &,std::string const &)\n"
    "    gum::LazyPropagation< double >::chgEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::LazyPropagation< double >::chgEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_hasEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_hasEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_hasEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LazyPropagation_Sl_double_Sg__hasEvidence__SWIG_0((gum::LazyPropagation< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_hasEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_hasEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LazyPropagation_Sl_double_Sg__hasEvidence__SWIG_1((gum::LazyPropagation< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_hasEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LazyPropagation_hasEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_hasEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_hasEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LazyPropagation_hasEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LazyPropagation< double >::hasEvidence(gum::NodeId const) const\n"
    "    gum::LazyPropagation< double >::hasEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_eraseAllEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_eraseAllEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__eraseAllEvidence(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_eraseEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_eraseEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_eraseEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__eraseEvidence__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_eraseEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_eraseEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__eraseEvidence__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_eraseEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LazyPropagation_eraseEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_eraseEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_eraseEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LazyPropagation_eraseEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LazyPropagation< double >::eraseEvidence(gum::NodeId const)\n"
    "    gum::LazyPropagation< double >::eraseEvidence(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_hasSoftEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_hasSoftEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_hasSoftEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LazyPropagation_Sl_double_Sg__hasSoftEvidence__SWIG_0((gum::LazyPropagation< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_hasHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_hasHardEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_hasHardEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LazyPropagation_Sl_double_Sg__hasHardEvidence((gum::LazyPropagation< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_hasSoftEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_hasSoftEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LazyPropagation_Sl_double_Sg__hasSoftEvidence__SWIG_1((gum::LazyPropagation< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_hasSoftEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LazyPropagation_hasSoftEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_hasSoftEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_hasSoftEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LazyPropagation_hasSoftEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LazyPropagation< double >::hasSoftEvidence(gum::NodeId const) const\n"
    "    gum::LazyPropagation< double >::hasSoftEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_nbrEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_nbrEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__nbrEvidence((gum::LazyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_nbrHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_nbrHardEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__nbrHardEvidence((gum::LazyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_nbrSoftEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_nbrSoftEvidence" "', argument " "1"" of type '" "gum::LazyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__nbrSoftEvidence((gum::LazyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_eraseAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_eraseAllTargets" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__eraseAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_addAllTargets" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__addAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_addTarget" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_addTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__addTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_addTarget" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__addTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_addTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LazyPropagation_addTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_addTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_addTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LazyPropagation_addTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LazyPropagation< double >::addTarget(gum::NodeId const)\n"
    "    gum::LazyPropagation< double >::addTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_eraseTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_eraseTarget" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_eraseTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__eraseTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_eraseTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_eraseTarget" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__eraseTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_eraseTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LazyPropagation_eraseTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_eraseTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_eraseTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LazyPropagation_eraseTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LazyPropagation< double >::eraseTarget(gum::NodeId const)\n"
    "    gum::LazyPropagation< double >::eraseTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_isTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_isTarget" "', argument " "1"" of type '" "gum::LazyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_isTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LazyPropagation_Sl_double_Sg__isTarget__SWIG_0((gum::LazyPropagation< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_isTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_isTarget" "', argument " "1"" of type '" "gum::LazyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LazyPropagation_Sl_double_Sg__isTarget__SWIG_1((gum::LazyPropagation< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_isTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LazyPropagation_isTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_isTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_isTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LazyPropagation_isTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LazyPropagation< double >::isTarget(gum::NodeId const) const\n"
    "    gum::LazyPropagation< double >::isTarget(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_nbrTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_nbrTargets" "', argument " "1"" of type '" "gum::LazyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__nbrTargets((gum::LazyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_H__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_H" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_H" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (double)gum_LazyPropagation_Sl_double_Sg__H__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_H__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_H" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (double)gum_LazyPropagation_Sl_double_Sg__H__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_H(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LazyPropagation_H", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_H__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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_LazyPropagation_H__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LazyPropagation_H'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LazyPropagation< double >::H(gum::NodeId const)\n"
    "    gum::LazyPropagation< double >::H(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_evidenceImpact__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_evidenceImpact" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LazyPropagation_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__evidenceImpact__SWIG_1(arg1,(std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_evidenceImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LazyPropagation_evidenceImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_LazyPropagation_evidenceImpact__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_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::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LazyPropagation_evidenceImpact__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LazyPropagation_evidenceImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LazyPropagation< double >::evidenceImpact(gum::NodeId,PyObject *)\n"
    "    gum::LazyPropagation< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_eraseAllJointTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_eraseAllJointTargets" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__eraseAllJointTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_eraseAllMarginalTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_eraseAllMarginalTargets" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      gum_LazyPropagation_Sl_double_Sg__eraseAllMarginalTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_nbrJointTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_nbrJointTargets" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__nbrJointTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_I(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_I", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_I" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_I" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LazyPropagation_I" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (double)gum_LazyPropagation_Sl_double_Sg__I(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_VI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyPropagation_VI", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_VI" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LazyPropagation_VI" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LazyPropagation_VI" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (double)gum_LazyPropagation_Sl_double_Sg__VI(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_evidenceJointImpact__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LazyPropagation< double > *arg1 = (gum::LazyPropagation< double > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LazyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyPropagation_evidenceJointImpact" "', argument " "1"" of type '" "gum::LazyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LazyPropagation< double > * >(argp1);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LazyPropagation_evidenceJointImpact" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_evidenceJointImpact" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LazyPropagation_evidenceJointImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LazyPropagation_evidenceJointImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_LazyPropagation_Sl_double_Sg__evidenceJointImpact__SWIG_1(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyPropagation_evidenceJointImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LazyPropagation_evidenceJointImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LazyPropagation_evidenceJointImpact__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LazyPropagationT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_LazyPropagation_evidenceJointImpact__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LazyPropagation_evidenceJointImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LazyPropagation< double >::evidenceJointImpact(PyObject *,PyObject *)\n"
    "    gum::LazyPropagation< double >::evidenceJointImpact(std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *LazyPropagation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__LazyPropagationT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LazyPropagation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ShaferShenoyInference__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::FindBarrenNodesType arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  gum::ShaferShenoyInference< double > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaferShenoyInference" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShaferShenoyInference" "', argument " "2"" of type '" "gum::FindBarrenNodesType""'");
  } 
  arg2 = static_cast< gum::FindBarrenNodesType >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ShaferShenoyInference" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (gum::ShaferShenoyInference< double > *)new gum::ShaferShenoyInference< double >((gum::IBayesNet< double > const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ShaferShenoyInference__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::FindBarrenNodesType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  gum::ShaferShenoyInference< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaferShenoyInference" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShaferShenoyInference" "', argument " "2"" of type '" "gum::FindBarrenNodesType""'");
  } 
  arg2 = static_cast< gum::FindBarrenNodesType >(val2);
  {
    try {
      result = (gum::ShaferShenoyInference< double > *)new gum::ShaferShenoyInference< double >((gum::IBayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ShaferShenoyInference__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::ShaferShenoyInference< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaferShenoyInference" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (gum::ShaferShenoyInference< double > *)new gum::ShaferShenoyInference< double >((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ShaferShenoyInference(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ShaferShenoyInference", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__IBayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ShaferShenoyInference__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__IBayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ShaferShenoyInference__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__IBayesNetT_double_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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ShaferShenoyInference__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ShaferShenoyInference'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyInference< double >::ShaferShenoyInference(gum::IBayesNet< double > const *,gum::FindBarrenNodesType,bool)\n"
    "    gum::ShaferShenoyInference< double >::ShaferShenoyInference(gum::IBayesNet< double > const *,gum::FindBarrenNodesType)\n"
    "    gum::ShaferShenoyInference< double >::ShaferShenoyInference(gum::IBayesNet< double > const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ShaferShenoyInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaferShenoyInference" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_setTriangulation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::Triangulation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_setTriangulation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_setTriangulation" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Triangulation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_setTriangulation" "', argument " "2"" of type '" "gum::Triangulation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_setTriangulation" "', argument " "2"" of type '" "gum::Triangulation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Triangulation * >(argp2);
  {
    try {
      (arg1)->setTriangulation((gum::Triangulation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_setFindBarrenNodesType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::FindBarrenNodesType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_setFindBarrenNodesType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_setFindBarrenNodesType" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_setFindBarrenNodesType" "', argument " "2"" of type '" "gum::FindBarrenNodesType""'");
  } 
  arg2 = static_cast< gum::FindBarrenNodesType >(val2);
  {
    try {
      (arg1)->setFindBarrenNodesType(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_joinTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::JoinTree *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_joinTree" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = (gum::JoinTree *)(arg1)->joinTree();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_junctionTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::JunctionTree *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_junctionTree" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = (gum::JunctionTree *)(arg1)->junctionTree();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_evidenceProbability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_evidenceProbability" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = (double)(arg1)->evidenceProbability();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_setEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_setEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_updateEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_updateEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_updateEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__updateEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_setTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_setTargets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_setTargets" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__setTargets(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_hardEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_hardEvidenceNodes" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_ShaferShenoyInference_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_softEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_softEvidenceNodes" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_ShaferShenoyInference_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_targets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_targets" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_ShaferShenoyInference_Sl_double_Sg__targets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_evidenceImpact__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_evidenceImpact" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_evidenceImpact" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_jointMutualInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_jointMutualInformation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_jointMutualInformation" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (double)gum_ShaferShenoyInference_Sl_double_Sg__jointMutualInformation(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_evidenceJointImpact__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_evidenceJointImpact" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__evidenceJointImpact__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_jointPosterior(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_jointPosterior", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_jointPosterior" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__jointPosterior(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addJointTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_addJointTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_addJointTarget" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__addJointTarget(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_eraseJointTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_eraseJointTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_eraseJointTarget" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__eraseJointTarget(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_isJointTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_isJointTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_isJointTarget" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (bool)gum_ShaferShenoyInference_Sl_double_Sg__isJointTarget(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_jointTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_jointTargets" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_ShaferShenoyInference_Sl_double_Sg__jointTargets((gum::ShaferShenoyInference< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_makeInference" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__makeInference(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_posterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_posterior" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_posterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__posterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_posterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_posterior" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ShaferShenoyInference_posterior" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__posterior__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_posterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_posterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_posterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_posterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyInference_posterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyInference< double >::posterior(gum::NodeId const)\n"
    "    gum::ShaferShenoyInference< double >::posterior(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_BN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_BN" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = (gum::IBayesNet< double > *) &gum_ShaferShenoyInference_Sl_double_Sg__BN((gum::ShaferShenoyInference< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__addEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__addEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__addEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__addEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShaferShenoyInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__addEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ShaferShenoyInference_addEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ShaferShenoyInference_addEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ShaferShenoyInference_addEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ShaferShenoyInference_addEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ShaferShenoyInference_addEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ShaferShenoyInference_addEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyInference_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyInference< double >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::ShaferShenoyInference< double >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::ShaferShenoyInference< double >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::ShaferShenoyInference< double >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::ShaferShenoyInference< double >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::ShaferShenoyInference< double >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_chgEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_chgEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_chgEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_chgEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_chgEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_chgEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__chgEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_chgEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_chgEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ShaferShenoyInference_chgEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ShaferShenoyInference_chgEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ShaferShenoyInference_chgEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ShaferShenoyInference_chgEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ShaferShenoyInference_chgEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ShaferShenoyInference_chgEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyInference_chgEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyInference< double >::chgEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::ShaferShenoyInference< double >::chgEvidence(std::string const &,gum::Idx const)\n"
    "    gum::ShaferShenoyInference< double >::chgEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::ShaferShenoyInference< double >::chgEvidence(std::string const &,std::string const &)\n"
    "    gum::ShaferShenoyInference< double >::chgEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::ShaferShenoyInference< double >::chgEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_hasEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_hasEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_hasEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_ShaferShenoyInference_Sl_double_Sg__hasEvidence__SWIG_0((gum::ShaferShenoyInference< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_hasEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_hasEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_ShaferShenoyInference_Sl_double_Sg__hasEvidence__SWIG_1((gum::ShaferShenoyInference< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_hasEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_hasEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_hasEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_hasEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyInference_hasEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyInference< double >::hasEvidence(gum::NodeId const) const\n"
    "    gum::ShaferShenoyInference< double >::hasEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_eraseAllEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_eraseAllEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__eraseAllEvidence(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_eraseEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_eraseEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_eraseEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__eraseEvidence__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_eraseEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_eraseEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__eraseEvidence__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_eraseEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_eraseEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_eraseEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_eraseEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyInference_eraseEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyInference< double >::eraseEvidence(gum::NodeId const)\n"
    "    gum::ShaferShenoyInference< double >::eraseEvidence(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_hasSoftEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_hasSoftEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_hasSoftEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_ShaferShenoyInference_Sl_double_Sg__hasSoftEvidence__SWIG_0((gum::ShaferShenoyInference< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_hasHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_hasHardEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_hasHardEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_ShaferShenoyInference_Sl_double_Sg__hasHardEvidence((gum::ShaferShenoyInference< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_hasSoftEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_hasSoftEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_ShaferShenoyInference_Sl_double_Sg__hasSoftEvidence__SWIG_1((gum::ShaferShenoyInference< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_hasSoftEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_hasSoftEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_hasSoftEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_hasSoftEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyInference_hasSoftEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyInference< double >::hasSoftEvidence(gum::NodeId const) const\n"
    "    gum::ShaferShenoyInference< double >::hasSoftEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_nbrEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_nbrEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__nbrEvidence((gum::ShaferShenoyInference< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_nbrHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_nbrHardEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__nbrHardEvidence((gum::ShaferShenoyInference< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_nbrSoftEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_nbrSoftEvidence" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__nbrSoftEvidence((gum::ShaferShenoyInference< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_eraseAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_eraseAllTargets" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__eraseAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_addAllTargets" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__addAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_addTarget" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_addTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__addTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_addTarget" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__addTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_addTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_addTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_addTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_addTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyInference_addTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyInference< double >::addTarget(gum::NodeId const)\n"
    "    gum::ShaferShenoyInference< double >::addTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_eraseTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_eraseTarget" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_eraseTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__eraseTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_eraseTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_eraseTarget" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__eraseTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_eraseTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_eraseTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_eraseTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_eraseTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyInference_eraseTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyInference< double >::eraseTarget(gum::NodeId const)\n"
    "    gum::ShaferShenoyInference< double >::eraseTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_isTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_isTarget" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_isTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_ShaferShenoyInference_Sl_double_Sg__isTarget__SWIG_0((gum::ShaferShenoyInference< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_isTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_isTarget" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_ShaferShenoyInference_Sl_double_Sg__isTarget__SWIG_1((gum::ShaferShenoyInference< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_isTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_isTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_isTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_isTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyInference_isTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyInference< double >::isTarget(gum::NodeId const) const\n"
    "    gum::ShaferShenoyInference< double >::isTarget(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_nbrTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_nbrTargets" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__nbrTargets((gum::ShaferShenoyInference< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_H__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_H" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_H" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (double)gum_ShaferShenoyInference_Sl_double_Sg__H__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_H__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_H" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (double)gum_ShaferShenoyInference_Sl_double_Sg__H__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_H(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_H", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_H__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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_ShaferShenoyInference_H__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyInference_H'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyInference< double >::H(gum::NodeId const)\n"
    "    gum::ShaferShenoyInference< double >::H(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_evidenceImpact__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_evidenceImpact" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShaferShenoyInference_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__evidenceImpact__SWIG_1(arg1,(std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_evidenceImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_evidenceImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_ShaferShenoyInference_evidenceImpact__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_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::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ShaferShenoyInference_evidenceImpact__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyInference_evidenceImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyInference< double >::evidenceImpact(gum::NodeId,PyObject *)\n"
    "    gum::ShaferShenoyInference< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_eraseAllJointTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_eraseAllJointTargets" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__eraseAllJointTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_eraseAllMarginalTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_eraseAllMarginalTargets" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      gum_ShaferShenoyInference_Sl_double_Sg__eraseAllMarginalTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_nbrJointTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_nbrJointTargets" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__nbrJointTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_I(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_I", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_I" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_I" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShaferShenoyInference_I" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (double)gum_ShaferShenoyInference_Sl_double_Sg__I(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_VI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_VI", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_VI" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaferShenoyInference_VI" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShaferShenoyInference_VI" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (double)gum_ShaferShenoyInference_Sl_double_Sg__VI(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_evidenceJointImpact__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ShaferShenoyInference< double > *arg1 = (gum::ShaferShenoyInference< double > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaferShenoyInference_evidenceJointImpact" "', argument " "1"" of type '" "gum::ShaferShenoyInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ShaferShenoyInference< double > * >(argp1);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaferShenoyInference_evidenceJointImpact" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_evidenceJointImpact" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShaferShenoyInference_evidenceJointImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaferShenoyInference_evidenceJointImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_ShaferShenoyInference_Sl_double_Sg__evidenceJointImpact__SWIG_1(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaferShenoyInference_evidenceJointImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShaferShenoyInference_evidenceJointImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ShaferShenoyInference_evidenceJointImpact__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_ShaferShenoyInference_evidenceJointImpact__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShaferShenoyInference_evidenceJointImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ShaferShenoyInference< double >::evidenceJointImpact(PyObject *,PyObject *)\n"
    "    gum::ShaferShenoyInference< double >::evidenceJointImpact(std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *ShaferShenoyInference_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__ShaferShenoyInferenceT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ShaferShenoyInference_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_VariableElimination__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::RelevantPotentialsFinderType arg2 ;
  gum::FindBarrenNodesType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  gum::VariableElimination< double > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VariableElimination" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VariableElimination" "', argument " "2"" of type '" "gum::RelevantPotentialsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantPotentialsFinderType >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VariableElimination" "', argument " "3"" of type '" "gum::FindBarrenNodesType""'");
  } 
  arg3 = static_cast< gum::FindBarrenNodesType >(val3);
  {
    try {
      result = (gum::VariableElimination< double > *)new gum::VariableElimination< double >((gum::IBayesNet< double > const *)arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__VariableEliminationT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VariableElimination__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  gum::RelevantPotentialsFinderType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  gum::VariableElimination< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VariableElimination" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VariableElimination" "', argument " "2"" of type '" "gum::RelevantPotentialsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantPotentialsFinderType >(val2);
  {
    try {
      result = (gum::VariableElimination< double > *)new gum::VariableElimination< double >((gum::IBayesNet< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__VariableEliminationT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VariableElimination__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::VariableElimination< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VariableElimination" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (gum::VariableElimination< double > *)new gum::VariableElimination< double >((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__VariableEliminationT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VariableElimination(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_VariableElimination", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__IBayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VariableElimination__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__IBayesNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_VariableElimination__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__IBayesNetT_double_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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_VariableElimination__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VariableElimination'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::VariableElimination< double >::VariableElimination(gum::IBayesNet< double > const *,gum::RelevantPotentialsFinderType,gum::FindBarrenNodesType)\n"
    "    gum::VariableElimination< double >::VariableElimination(gum::IBayesNet< double > const *,gum::RelevantPotentialsFinderType)\n"
    "    gum::VariableElimination< double >::VariableElimination(gum::IBayesNet< double > const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_VariableElimination(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VariableElimination" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_setTriangulation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::Triangulation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_setTriangulation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_setTriangulation" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Triangulation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_setTriangulation" "', argument " "2"" of type '" "gum::Triangulation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_setTriangulation" "', argument " "2"" of type '" "gum::Triangulation const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Triangulation * >(argp2);
  {
    try {
      (arg1)->setTriangulation((gum::Triangulation const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_setRelevantPotentialsFinderType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::RelevantPotentialsFinderType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_setRelevantPotentialsFinderType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_setRelevantPotentialsFinderType" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_setRelevantPotentialsFinderType" "', argument " "2"" of type '" "gum::RelevantPotentialsFinderType""'");
  } 
  arg2 = static_cast< gum::RelevantPotentialsFinderType >(val2);
  {
    try {
      (arg1)->setRelevantPotentialsFinderType(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_setFindBarrenNodesType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::FindBarrenNodesType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_setFindBarrenNodesType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_setFindBarrenNodesType" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_setFindBarrenNodesType" "', argument " "2"" of type '" "gum::FindBarrenNodesType""'");
  } 
  arg2 = static_cast< gum::FindBarrenNodesType >(val2);
  {
    try {
      (arg1)->setFindBarrenNodesType(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_junctionTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::JunctionTree *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_junctionTree", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_junctionTree" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_junctionTree" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::JunctionTree *)(arg1)->junctionTree(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__CliqueGraph, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_setEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_setEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_VariableElimination_Sl_double_Sg__setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_updateEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_updateEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_updateEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_VariableElimination_Sl_double_Sg__updateEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_setTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_setTargets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_setTargets" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_VariableElimination_Sl_double_Sg__setTargets(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_hardEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_hardEvidenceNodes" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_VariableElimination_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_softEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_softEvidenceNodes" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_VariableElimination_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_targets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_targets" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_VariableElimination_Sl_double_Sg__targets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_evidenceImpact__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_evidenceImpact" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_evidenceImpact" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = gum_VariableElimination_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_jointMutualInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_jointMutualInformation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_jointMutualInformation" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (double)gum_VariableElimination_Sl_double_Sg__jointMutualInformation(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_evidenceJointImpact(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_evidenceJointImpact", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_evidenceJointImpact" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = gum_VariableElimination_Sl_double_Sg__evidenceJointImpact(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_jointPosterior(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > result;
  
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_jointPosterior", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_jointPosterior" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = gum_VariableElimination_Sl_double_Sg__jointPosterior(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_addJointTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_addJointTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_addJointTarget" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_VariableElimination_Sl_double_Sg__addJointTarget(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_eraseJointTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_eraseJointTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_eraseJointTarget" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_VariableElimination_Sl_double_Sg__eraseJointTarget(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_isJointTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_isJointTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_isJointTarget" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (bool)gum_VariableElimination_Sl_double_Sg__isJointTarget(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_jointTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_jointTargets" "', argument " "1"" of type '" "gum::VariableElimination< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_VariableElimination_Sl_double_Sg__jointTargets((gum::VariableElimination< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_makeInference" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      gum_VariableElimination_Sl_double_Sg__makeInference(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_posterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_posterior" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_posterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_VariableElimination_Sl_double_Sg__posterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_posterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_posterior" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "VariableElimination_posterior" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_VariableElimination_Sl_double_Sg__posterior__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_posterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VariableElimination_posterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_posterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_posterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VariableElimination_posterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::VariableElimination< double >::posterior(gum::NodeId const)\n"
    "    gum::VariableElimination< double >::posterior(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VariableElimination_BN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_BN" "', argument " "1"" of type '" "gum::VariableElimination< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      result = (gum::IBayesNet< double > *) &gum_VariableElimination_Sl_double_Sg__BN((gum::VariableElimination< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_addEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_addEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VariableElimination_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_VariableElimination_Sl_double_Sg__addEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_addEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_addEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VariableElimination_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_VariableElimination_Sl_double_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_addEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_addEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VariableElimination_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_VariableElimination_Sl_double_Sg__addEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_addEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_addEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VariableElimination_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_VariableElimination_Sl_double_Sg__addEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_addEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_addEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VariableElimination_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_VariableElimination_Sl_double_Sg__addEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_addEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_addEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VariableElimination_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_VariableElimination_Sl_double_Sg__addEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VariableElimination_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VariableElimination_addEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VariableElimination_addEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VariableElimination_addEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VariableElimination_addEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VariableElimination_addEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VariableElimination_addEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VariableElimination_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::VariableElimination< double >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::VariableElimination< double >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::VariableElimination< double >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::VariableElimination< double >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::VariableElimination< double >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::VariableElimination< double >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VariableElimination_chgEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_chgEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VariableElimination_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_chgEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_chgEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VariableElimination_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_chgEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_chgEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VariableElimination_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_chgEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_chgEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VariableElimination_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_chgEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_chgEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VariableElimination_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_chgEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_chgEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VariableElimination_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_VariableElimination_Sl_double_Sg__chgEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_chgEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VariableElimination_chgEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VariableElimination_chgEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VariableElimination_chgEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VariableElimination_chgEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VariableElimination_chgEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VariableElimination_chgEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VariableElimination_chgEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VariableElimination_chgEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::VariableElimination< double >::chgEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::VariableElimination< double >::chgEvidence(std::string const &,gum::Idx const)\n"
    "    gum::VariableElimination< double >::chgEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::VariableElimination< double >::chgEvidence(std::string const &,std::string const &)\n"
    "    gum::VariableElimination< double >::chgEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::VariableElimination< double >::chgEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VariableElimination_hasEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_hasEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_hasEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_VariableElimination_Sl_double_Sg__hasEvidence__SWIG_0((gum::VariableElimination< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_hasEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_hasEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_VariableElimination_Sl_double_Sg__hasEvidence__SWIG_1((gum::VariableElimination< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_hasEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VariableElimination_hasEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_hasEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_hasEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VariableElimination_hasEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::VariableElimination< double >::hasEvidence(gum::NodeId const) const\n"
    "    gum::VariableElimination< double >::hasEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VariableElimination_eraseAllEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_eraseAllEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      gum_VariableElimination_Sl_double_Sg__eraseAllEvidence(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_eraseEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_eraseEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_eraseEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_VariableElimination_Sl_double_Sg__eraseEvidence__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_eraseEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_eraseEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_VariableElimination_Sl_double_Sg__eraseEvidence__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_eraseEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VariableElimination_eraseEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_eraseEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_eraseEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VariableElimination_eraseEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::VariableElimination< double >::eraseEvidence(gum::NodeId const)\n"
    "    gum::VariableElimination< double >::eraseEvidence(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VariableElimination_hasSoftEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_hasSoftEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_hasSoftEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_VariableElimination_Sl_double_Sg__hasSoftEvidence__SWIG_0((gum::VariableElimination< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_hasHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "VariableElimination_hasHardEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_hasHardEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_VariableElimination_Sl_double_Sg__hasHardEvidence((gum::VariableElimination< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_hasSoftEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_hasSoftEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_VariableElimination_Sl_double_Sg__hasSoftEvidence__SWIG_1((gum::VariableElimination< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_hasSoftEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VariableElimination_hasSoftEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_hasSoftEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_hasSoftEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VariableElimination_hasSoftEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::VariableElimination< double >::hasSoftEvidence(gum::NodeId const) const\n"
    "    gum::VariableElimination< double >::hasSoftEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VariableElimination_nbrEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_nbrEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      result = gum_VariableElimination_Sl_double_Sg__nbrEvidence((gum::VariableElimination< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_nbrHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_nbrHardEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      result = gum_VariableElimination_Sl_double_Sg__nbrHardEvidence((gum::VariableElimination< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_nbrSoftEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_nbrSoftEvidence" "', argument " "1"" of type '" "gum::VariableElimination< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      result = gum_VariableElimination_Sl_double_Sg__nbrSoftEvidence((gum::VariableElimination< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_eraseAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_eraseAllTargets" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      gum_VariableElimination_Sl_double_Sg__eraseAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_addAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_addAllTargets" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      gum_VariableElimination_Sl_double_Sg__addAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_addTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_addTarget" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_addTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_VariableElimination_Sl_double_Sg__addTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_addTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_addTarget" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_VariableElimination_Sl_double_Sg__addTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_addTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VariableElimination_addTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_addTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_addTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VariableElimination_addTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::VariableElimination< double >::addTarget(gum::NodeId const)\n"
    "    gum::VariableElimination< double >::addTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VariableElimination_eraseTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_eraseTarget" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_eraseTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_VariableElimination_Sl_double_Sg__eraseTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_eraseTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_eraseTarget" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_VariableElimination_Sl_double_Sg__eraseTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_eraseTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VariableElimination_eraseTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_eraseTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_eraseTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VariableElimination_eraseTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::VariableElimination< double >::eraseTarget(gum::NodeId const)\n"
    "    gum::VariableElimination< double >::eraseTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VariableElimination_isTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_isTarget" "', argument " "1"" of type '" "gum::VariableElimination< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_isTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_VariableElimination_Sl_double_Sg__isTarget__SWIG_0((gum::VariableElimination< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_isTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_isTarget" "', argument " "1"" of type '" "gum::VariableElimination< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_VariableElimination_Sl_double_Sg__isTarget__SWIG_1((gum::VariableElimination< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_isTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VariableElimination_isTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_isTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_isTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VariableElimination_isTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::VariableElimination< double >::isTarget(gum::NodeId const) const\n"
    "    gum::VariableElimination< double >::isTarget(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VariableElimination_nbrTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_nbrTargets" "', argument " "1"" of type '" "gum::VariableElimination< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    try {
      result = gum_VariableElimination_Sl_double_Sg__nbrTargets((gum::VariableElimination< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_H__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_H" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VariableElimination_H" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (double)gum_VariableElimination_Sl_double_Sg__H__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_H__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_H" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (double)gum_VariableElimination_Sl_double_Sg__H__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_H(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VariableElimination_H", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_H__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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_VariableElimination_H__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VariableElimination_H'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::VariableElimination< double >::H(gum::NodeId const)\n"
    "    gum::VariableElimination< double >::H(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VariableElimination_evidenceImpact__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::VariableElimination< double > *arg1 = (gum::VariableElimination< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__VariableEliminationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VariableElimination_evidenceImpact" "', argument " "1"" of type '" "gum::VariableElimination< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::VariableElimination< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VariableElimination_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VariableElimination_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VariableElimination_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_VariableElimination_Sl_double_Sg__evidenceImpact__SWIG_1(arg1,(std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VariableElimination_evidenceImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VariableElimination_evidenceImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_VariableElimination_evidenceImpact__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__VariableEliminationT_double_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::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VariableElimination_evidenceImpact__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VariableElimination_evidenceImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::VariableElimination< double >::evidenceImpact(gum::NodeId,PyObject *)\n"
    "    gum::VariableElimination< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *VariableElimination_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__VariableEliminationT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *VariableElimination_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GibbsSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::GibbsSampling< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GibbsSampling" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (gum::GibbsSampling< double > *)new gum::GibbsSampling< double >((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__GibbsSamplingT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GibbsSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GibbsSampling" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_setBurnIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsSampling_setBurnIn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_setBurnIn" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_setBurnIn" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      (arg1)->setBurnIn(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_burnIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_burnIn" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = ((gum::GibbsSampling< double > const *)arg1)->burnIn();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_setEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsSampling_setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_setEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_updateEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsSampling_updateEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_updateEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__updateEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_setTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsSampling_setTargets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_setTargets" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__setTargets(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_hardEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_hardEvidenceNodes" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_GibbsSampling_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_softEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_softEvidenceNodes" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_GibbsSampling_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_targets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_targets" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_GibbsSampling_Sl_double_Sg__targets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_evidenceImpact__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_evidenceImpact" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_evidenceImpact" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_setVerbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsSampling_setVerbosity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_setVerbosity" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_setVerbosity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__setVerbosity(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_setEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsSampling_setEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_setEpsilon" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_setEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__setEpsilon(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_setMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsSampling_setMinEpsilonRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_setMinEpsilonRate" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_setMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__setMinEpsilonRate(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_setMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsSampling_setMaxIter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_setMaxIter" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_setMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__setMaxIter(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_setMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsSampling_setMaxTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_setMaxTime" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_setMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__setMaxTime(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_setPeriodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsSampling_setPeriodSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_setPeriodSize" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_setPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__setPeriodSize(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_verbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_verbosity" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = (bool)gum_GibbsSampling_Sl_double_Sg__verbosity((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_epsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_epsilon" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_GibbsSampling_Sl_double_Sg__epsilon((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_minEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_minEpsilonRate" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_GibbsSampling_Sl_double_Sg__minEpsilonRate((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_maxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_maxIter" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__maxIter((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_maxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_maxTime" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_GibbsSampling_Sl_double_Sg__maxTime((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_periodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_periodSize" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__periodSize((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_nbrIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_nbrIterations" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__nbrIterations((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_currentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_currentTime" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_GibbsSampling_Sl_double_Sg__currentTime((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_messageApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_messageApproximationScheme" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__messageApproximationScheme((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_history" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_GibbsSampling_Sl_double_Sg__history((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_asIApproximationSchemeConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_asIApproximationSchemeConfiguration" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration *) &gum_GibbsSampling_Sl_double_Sg__asIApproximationSchemeConfiguration((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IApproximationSchemeConfiguration, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_makeInference" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__makeInference(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_posterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_posterior" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_posterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__posterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_posterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_posterior" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "GibbsSampling_posterior" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__posterior__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_posterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GibbsSampling_posterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_posterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_posterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GibbsSampling_posterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GibbsSampling< double >::posterior(gum::NodeId const)\n"
    "    gum::GibbsSampling< double >::posterior(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_BN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_BN" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = (gum::IBayesNet< double > *) &gum_GibbsSampling_Sl_double_Sg__BN((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_addEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_addEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GibbsSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__addEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_addEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_addEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GibbsSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_addEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_addEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GibbsSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__addEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_addEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_addEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GibbsSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__addEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_addEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_addEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GibbsSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__addEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_addEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_addEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GibbsSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__addEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GibbsSampling_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GibbsSampling_addEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GibbsSampling_addEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GibbsSampling_addEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GibbsSampling_addEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GibbsSampling_addEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GibbsSampling_addEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GibbsSampling_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GibbsSampling< double >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::GibbsSampling< double >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::GibbsSampling< double >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::GibbsSampling< double >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::GibbsSampling< double >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::GibbsSampling< double >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_chgEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_chgEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GibbsSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_chgEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_chgEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GibbsSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_chgEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_chgEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_chgEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_chgEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_chgEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_chgEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_chgEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_chgEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__chgEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_chgEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GibbsSampling_chgEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GibbsSampling_chgEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GibbsSampling_chgEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GibbsSampling_chgEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GibbsSampling_chgEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GibbsSampling_chgEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GibbsSampling_chgEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GibbsSampling_chgEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GibbsSampling< double >::chgEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::GibbsSampling< double >::chgEvidence(std::string const &,gum::Idx const)\n"
    "    gum::GibbsSampling< double >::chgEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::GibbsSampling< double >::chgEvidence(std::string const &,std::string const &)\n"
    "    gum::GibbsSampling< double >::chgEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::GibbsSampling< double >::chgEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_hasEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_hasEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_hasEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_GibbsSampling_Sl_double_Sg__hasEvidence__SWIG_0((gum::GibbsSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_hasEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_hasEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_GibbsSampling_Sl_double_Sg__hasEvidence__SWIG_1((gum::GibbsSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_hasEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GibbsSampling_hasEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_hasEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_hasEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GibbsSampling_hasEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GibbsSampling< double >::hasEvidence(gum::NodeId const) const\n"
    "    gum::GibbsSampling< double >::hasEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_eraseAllEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_eraseAllEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__eraseAllEvidence(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_eraseEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_eraseEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_eraseEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__eraseEvidence__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_eraseEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_eraseEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__eraseEvidence__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_eraseEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GibbsSampling_eraseEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_eraseEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_eraseEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GibbsSampling_eraseEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GibbsSampling< double >::eraseEvidence(gum::NodeId const)\n"
    "    gum::GibbsSampling< double >::eraseEvidence(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_hasSoftEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_hasSoftEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_GibbsSampling_Sl_double_Sg__hasSoftEvidence__SWIG_0((gum::GibbsSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_hasHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsSampling_hasHardEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_hasHardEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_GibbsSampling_Sl_double_Sg__hasHardEvidence((gum::GibbsSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_hasSoftEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_GibbsSampling_Sl_double_Sg__hasSoftEvidence__SWIG_1((gum::GibbsSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_hasSoftEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GibbsSampling_hasSoftEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GibbsSampling_hasSoftEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GibbsSampling< double >::hasSoftEvidence(gum::NodeId const) const\n"
    "    gum::GibbsSampling< double >::hasSoftEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_nbrEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_nbrEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__nbrEvidence((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_nbrHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_nbrHardEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__nbrHardEvidence((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_nbrSoftEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_nbrSoftEvidence" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__nbrSoftEvidence((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_eraseAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_eraseAllTargets" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__eraseAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_addAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_addAllTargets" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__addAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_addTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_addTarget" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_addTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__addTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_addTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_addTarget" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__addTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_addTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GibbsSampling_addTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_addTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_addTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GibbsSampling_addTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GibbsSampling< double >::addTarget(gum::NodeId const)\n"
    "    gum::GibbsSampling< double >::addTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_eraseTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_eraseTarget" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_eraseTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__eraseTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_eraseTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_eraseTarget" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__eraseTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_eraseTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GibbsSampling_eraseTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_eraseTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_eraseTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GibbsSampling_eraseTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GibbsSampling< double >::eraseTarget(gum::NodeId const)\n"
    "    gum::GibbsSampling< double >::eraseTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_isTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_isTarget" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_isTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_GibbsSampling_Sl_double_Sg__isTarget__SWIG_0((gum::GibbsSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_isTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_isTarget" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_GibbsSampling_Sl_double_Sg__isTarget__SWIG_1((gum::GibbsSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_isTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GibbsSampling_isTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_isTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_isTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GibbsSampling_isTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GibbsSampling< double >::isTarget(gum::NodeId const) const\n"
    "    gum::GibbsSampling< double >::isTarget(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_nbrTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_nbrTargets" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__nbrTargets((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_H__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_H" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_H" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (double)gum_GibbsSampling_Sl_double_Sg__H__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_H__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_H" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (double)gum_GibbsSampling_Sl_double_Sg__H__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_H(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GibbsSampling_H", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_H__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_H__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GibbsSampling_H'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GibbsSampling< double >::H(gum::NodeId const)\n"
    "    gum::GibbsSampling< double >::H(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_evidenceImpact__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_evidenceImpact" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GibbsSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__evidenceImpact__SWIG_1(arg1,(std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_evidenceImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GibbsSampling_evidenceImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_GibbsSampling_evidenceImpact__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GibbsSampling_evidenceImpact__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GibbsSampling_evidenceImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GibbsSampling< double >::evidenceImpact(gum::NodeId,PyObject *)\n"
    "    gum::GibbsSampling< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_currentPosterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_currentPosterior" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_currentPosterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Potential< double > *) &gum_GibbsSampling_Sl_double_Sg__currentPosterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_currentPosterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_currentPosterior" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GibbsSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GibbsSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Potential< double > *) &gum_GibbsSampling_Sl_double_Sg__currentPosterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_currentPosterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GibbsSampling_currentPosterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_currentPosterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__GibbsSamplingT_double_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_GibbsSampling_currentPosterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GibbsSampling_currentPosterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GibbsSampling< double >::currentPosterior(gum::NodeId const)\n"
    "    gum::GibbsSampling< double >::currentPosterior(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_nbrDrawnVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_nbrDrawnVar" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = gum_GibbsSampling_Sl_double_Sg__nbrDrawnVar((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_setNbrDrawnVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsSampling_setNbrDrawnVar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_setNbrDrawnVar" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_setNbrDrawnVar" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__setNbrDrawnVar(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_isDrawnAtRandom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_isDrawnAtRandom" "', argument " "1"" of type '" "gum::GibbsSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  {
    try {
      result = (bool)gum_GibbsSampling_Sl_double_Sg__isDrawnAtRandom((gum::GibbsSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsSampling_setDrawnAtRandom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsSampling< double > *arg1 = (gum::GibbsSampling< double > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsSampling_setDrawnAtRandom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsSampling_setDrawnAtRandom" "', argument " "1"" of type '" "gum::GibbsSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsSampling_setDrawnAtRandom" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_GibbsSampling_Sl_double_Sg__setDrawnAtRandom(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GibbsSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__GibbsSamplingT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GibbsSampling_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ImportanceSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::ImportanceSampling< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImportanceSampling" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (gum::ImportanceSampling< double > *)new gum::ImportanceSampling< double >((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ImportanceSamplingT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ImportanceSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImportanceSampling" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_setEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ImportanceSampling_setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_setEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_updateEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ImportanceSampling_updateEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_updateEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__updateEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_setTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ImportanceSampling_setTargets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_setTargets" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__setTargets(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_hardEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_hardEvidenceNodes" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_ImportanceSampling_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_softEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_softEvidenceNodes" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_ImportanceSampling_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_targets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_targets" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_ImportanceSampling_Sl_double_Sg__targets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_evidenceImpact__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_evidenceImpact" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_evidenceImpact" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = gum_ImportanceSampling_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_setVerbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ImportanceSampling_setVerbosity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_setVerbosity" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_setVerbosity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__setVerbosity(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_setEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ImportanceSampling_setEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_setEpsilon" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_setEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__setEpsilon(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_setMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ImportanceSampling_setMinEpsilonRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_setMinEpsilonRate" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_setMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__setMinEpsilonRate(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_setMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ImportanceSampling_setMaxIter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_setMaxIter" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_setMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__setMaxIter(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_setMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ImportanceSampling_setMaxTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_setMaxTime" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_setMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__setMaxTime(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_setPeriodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ImportanceSampling_setPeriodSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_setPeriodSize" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_setPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__setPeriodSize(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_verbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_verbosity" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = (bool)gum_ImportanceSampling_Sl_double_Sg__verbosity((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_epsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_epsilon" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_ImportanceSampling_Sl_double_Sg__epsilon((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_minEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_minEpsilonRate" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_ImportanceSampling_Sl_double_Sg__minEpsilonRate((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_maxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_maxIter" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = gum_ImportanceSampling_Sl_double_Sg__maxIter((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_maxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_maxTime" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_ImportanceSampling_Sl_double_Sg__maxTime((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_periodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_periodSize" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = gum_ImportanceSampling_Sl_double_Sg__periodSize((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_nbrIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_nbrIterations" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = gum_ImportanceSampling_Sl_double_Sg__nbrIterations((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_currentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_currentTime" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_ImportanceSampling_Sl_double_Sg__currentTime((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_messageApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_messageApproximationScheme" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = gum_ImportanceSampling_Sl_double_Sg__messageApproximationScheme((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_history" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_ImportanceSampling_Sl_double_Sg__history((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_asIApproximationSchemeConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_asIApproximationSchemeConfiguration" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration *) &gum_ImportanceSampling_Sl_double_Sg__asIApproximationSchemeConfiguration((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IApproximationSchemeConfiguration, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_makeInference" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__makeInference(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_posterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_posterior" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_posterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_ImportanceSampling_Sl_double_Sg__posterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_posterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_posterior" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ImportanceSampling_posterior" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_ImportanceSampling_Sl_double_Sg__posterior__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_posterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ImportanceSampling_posterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_posterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_posterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ImportanceSampling_posterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ImportanceSampling< double >::posterior(gum::NodeId const)\n"
    "    gum::ImportanceSampling< double >::posterior(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_BN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_BN" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = (gum::IBayesNet< double > *) &gum_ImportanceSampling_Sl_double_Sg__BN((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_addEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_addEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImportanceSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__addEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_addEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_addEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImportanceSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_addEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_addEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__addEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_addEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_addEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__addEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_addEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_addEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__addEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_addEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_addEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__addEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ImportanceSampling_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ImportanceSampling_addEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ImportanceSampling_addEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ImportanceSampling_addEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ImportanceSampling_addEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ImportanceSampling_addEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ImportanceSampling_addEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ImportanceSampling_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ImportanceSampling< double >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::ImportanceSampling< double >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::ImportanceSampling< double >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::ImportanceSampling< double >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::ImportanceSampling< double >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::ImportanceSampling< double >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_chgEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_chgEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImportanceSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_chgEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_chgEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImportanceSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_chgEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_chgEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_chgEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_chgEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_chgEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_chgEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_chgEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_chgEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__chgEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_chgEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ImportanceSampling_chgEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ImportanceSampling_chgEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ImportanceSampling_chgEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ImportanceSampling_chgEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ImportanceSampling_chgEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ImportanceSampling_chgEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ImportanceSampling_chgEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ImportanceSampling_chgEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ImportanceSampling< double >::chgEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::ImportanceSampling< double >::chgEvidence(std::string const &,gum::Idx const)\n"
    "    gum::ImportanceSampling< double >::chgEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::ImportanceSampling< double >::chgEvidence(std::string const &,std::string const &)\n"
    "    gum::ImportanceSampling< double >::chgEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::ImportanceSampling< double >::chgEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_hasEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_hasEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_hasEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_ImportanceSampling_Sl_double_Sg__hasEvidence__SWIG_0((gum::ImportanceSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_hasEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_hasEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_ImportanceSampling_Sl_double_Sg__hasEvidence__SWIG_1((gum::ImportanceSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_hasEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ImportanceSampling_hasEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_hasEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_hasEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ImportanceSampling_hasEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ImportanceSampling< double >::hasEvidence(gum::NodeId const) const\n"
    "    gum::ImportanceSampling< double >::hasEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_eraseAllEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_eraseAllEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__eraseAllEvidence(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_eraseEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_eraseEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_eraseEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__eraseEvidence__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_eraseEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_eraseEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__eraseEvidence__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_eraseEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ImportanceSampling_eraseEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_eraseEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_eraseEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ImportanceSampling_eraseEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ImportanceSampling< double >::eraseEvidence(gum::NodeId const)\n"
    "    gum::ImportanceSampling< double >::eraseEvidence(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_hasSoftEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_hasSoftEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_ImportanceSampling_Sl_double_Sg__hasSoftEvidence__SWIG_0((gum::ImportanceSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_hasHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ImportanceSampling_hasHardEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_hasHardEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_ImportanceSampling_Sl_double_Sg__hasHardEvidence((gum::ImportanceSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_hasSoftEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_ImportanceSampling_Sl_double_Sg__hasSoftEvidence__SWIG_1((gum::ImportanceSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_hasSoftEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ImportanceSampling_hasSoftEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ImportanceSampling_hasSoftEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ImportanceSampling< double >::hasSoftEvidence(gum::NodeId const) const\n"
    "    gum::ImportanceSampling< double >::hasSoftEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_nbrEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_nbrEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = gum_ImportanceSampling_Sl_double_Sg__nbrEvidence((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_nbrHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_nbrHardEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = gum_ImportanceSampling_Sl_double_Sg__nbrHardEvidence((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_nbrSoftEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_nbrSoftEvidence" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = gum_ImportanceSampling_Sl_double_Sg__nbrSoftEvidence((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_eraseAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_eraseAllTargets" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__eraseAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_addAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_addAllTargets" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__addAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_addTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_addTarget" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_addTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__addTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_addTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_addTarget" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__addTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_addTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ImportanceSampling_addTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_addTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_addTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ImportanceSampling_addTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ImportanceSampling< double >::addTarget(gum::NodeId const)\n"
    "    gum::ImportanceSampling< double >::addTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_eraseTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_eraseTarget" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_eraseTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__eraseTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_eraseTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_eraseTarget" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_ImportanceSampling_Sl_double_Sg__eraseTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_eraseTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ImportanceSampling_eraseTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_eraseTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_eraseTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ImportanceSampling_eraseTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ImportanceSampling< double >::eraseTarget(gum::NodeId const)\n"
    "    gum::ImportanceSampling< double >::eraseTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_isTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_isTarget" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_isTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_ImportanceSampling_Sl_double_Sg__isTarget__SWIG_0((gum::ImportanceSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_isTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_isTarget" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_ImportanceSampling_Sl_double_Sg__isTarget__SWIG_1((gum::ImportanceSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_isTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ImportanceSampling_isTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_isTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_isTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ImportanceSampling_isTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ImportanceSampling< double >::isTarget(gum::NodeId const) const\n"
    "    gum::ImportanceSampling< double >::isTarget(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_nbrTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_nbrTargets" "', argument " "1"" of type '" "gum::ImportanceSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    try {
      result = gum_ImportanceSampling_Sl_double_Sg__nbrTargets((gum::ImportanceSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_H__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_H" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_H" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (double)gum_ImportanceSampling_Sl_double_Sg__H__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_H__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_H" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (double)gum_ImportanceSampling_Sl_double_Sg__H__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_H(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ImportanceSampling_H", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_H__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_H__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ImportanceSampling_H'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ImportanceSampling< double >::H(gum::NodeId const)\n"
    "    gum::ImportanceSampling< double >::H(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_evidenceImpact__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_evidenceImpact" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImportanceSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_ImportanceSampling_Sl_double_Sg__evidenceImpact__SWIG_1(arg1,(std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_evidenceImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ImportanceSampling_evidenceImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_ImportanceSampling_evidenceImpact__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ImportanceSampling_evidenceImpact__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ImportanceSampling_evidenceImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ImportanceSampling< double >::evidenceImpact(gum::NodeId,PyObject *)\n"
    "    gum::ImportanceSampling< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_currentPosterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_currentPosterior" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImportanceSampling_currentPosterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Potential< double > *) &gum_ImportanceSampling_Sl_double_Sg__currentPosterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_currentPosterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::ImportanceSampling< double > *arg1 = (gum::ImportanceSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ImportanceSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImportanceSampling_currentPosterior" "', argument " "1"" of type '" "gum::ImportanceSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ImportanceSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImportanceSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImportanceSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Potential< double > *) &gum_ImportanceSampling_Sl_double_Sg__currentPosterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImportanceSampling_currentPosterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ImportanceSampling_currentPosterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_currentPosterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__ImportanceSamplingT_double_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_ImportanceSampling_currentPosterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ImportanceSampling_currentPosterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ImportanceSampling< double >::currentPosterior(gum::NodeId const)\n"
    "    gum::ImportanceSampling< double >::currentPosterior(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *ImportanceSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__ImportanceSamplingT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ImportanceSampling_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_WeightedSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::WeightedSampling< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WeightedSampling" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (gum::WeightedSampling< double > *)new gum::WeightedSampling< double >((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__WeightedSamplingT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_WeightedSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WeightedSampling" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_setEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "WeightedSampling_setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_setEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_updateEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "WeightedSampling_updateEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_updateEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__updateEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_setTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "WeightedSampling_setTargets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_setTargets" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__setTargets(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_hardEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_hardEvidenceNodes" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_WeightedSampling_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_softEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_softEvidenceNodes" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_WeightedSampling_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_targets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_targets" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_WeightedSampling_Sl_double_Sg__targets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_evidenceImpact__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_evidenceImpact" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_evidenceImpact" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = gum_WeightedSampling_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_setVerbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "WeightedSampling_setVerbosity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_setVerbosity" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_setVerbosity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__setVerbosity(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_setEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "WeightedSampling_setEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_setEpsilon" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_setEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__setEpsilon(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_setMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "WeightedSampling_setMinEpsilonRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_setMinEpsilonRate" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_setMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__setMinEpsilonRate(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_setMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "WeightedSampling_setMaxIter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_setMaxIter" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_setMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__setMaxIter(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_setMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "WeightedSampling_setMaxTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_setMaxTime" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_setMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__setMaxTime(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_setPeriodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "WeightedSampling_setPeriodSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_setPeriodSize" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_setPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__setPeriodSize(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_verbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_verbosity" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = (bool)gum_WeightedSampling_Sl_double_Sg__verbosity((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_epsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_epsilon" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_WeightedSampling_Sl_double_Sg__epsilon((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_minEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_minEpsilonRate" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_WeightedSampling_Sl_double_Sg__minEpsilonRate((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_maxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_maxIter" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = gum_WeightedSampling_Sl_double_Sg__maxIter((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_maxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_maxTime" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_WeightedSampling_Sl_double_Sg__maxTime((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_periodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_periodSize" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = gum_WeightedSampling_Sl_double_Sg__periodSize((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_nbrIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_nbrIterations" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = gum_WeightedSampling_Sl_double_Sg__nbrIterations((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_currentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_currentTime" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_WeightedSampling_Sl_double_Sg__currentTime((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_messageApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_messageApproximationScheme" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = gum_WeightedSampling_Sl_double_Sg__messageApproximationScheme((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_history" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_WeightedSampling_Sl_double_Sg__history((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_asIApproximationSchemeConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_asIApproximationSchemeConfiguration" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration *) &gum_WeightedSampling_Sl_double_Sg__asIApproximationSchemeConfiguration((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IApproximationSchemeConfiguration, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_makeInference" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__makeInference(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_posterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_posterior" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_posterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_WeightedSampling_Sl_double_Sg__posterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_posterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_posterior" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "WeightedSampling_posterior" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_WeightedSampling_Sl_double_Sg__posterior__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_posterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WeightedSampling_posterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_posterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_posterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WeightedSampling_posterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::WeightedSampling< double >::posterior(gum::NodeId const)\n"
    "    gum::WeightedSampling< double >::posterior(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_BN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_BN" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = (gum::IBayesNet< double > *) &gum_WeightedSampling_Sl_double_Sg__BN((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_addEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_addEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WeightedSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__addEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_addEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_addEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WeightedSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_addEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_addEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WeightedSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__addEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_addEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_addEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WeightedSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__addEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_addEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_addEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WeightedSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__addEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_addEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_addEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WeightedSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__addEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WeightedSampling_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_WeightedSampling_addEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_WeightedSampling_addEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_WeightedSampling_addEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_WeightedSampling_addEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_WeightedSampling_addEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_WeightedSampling_addEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WeightedSampling_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::WeightedSampling< double >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::WeightedSampling< double >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::WeightedSampling< double >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::WeightedSampling< double >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::WeightedSampling< double >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::WeightedSampling< double >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_chgEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_chgEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WeightedSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_chgEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_chgEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WeightedSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_chgEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_chgEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_chgEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_chgEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_chgEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_chgEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_chgEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_chgEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__chgEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_chgEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WeightedSampling_chgEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_WeightedSampling_chgEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_WeightedSampling_chgEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_WeightedSampling_chgEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_WeightedSampling_chgEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_WeightedSampling_chgEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_WeightedSampling_chgEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WeightedSampling_chgEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::WeightedSampling< double >::chgEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::WeightedSampling< double >::chgEvidence(std::string const &,gum::Idx const)\n"
    "    gum::WeightedSampling< double >::chgEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::WeightedSampling< double >::chgEvidence(std::string const &,std::string const &)\n"
    "    gum::WeightedSampling< double >::chgEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::WeightedSampling< double >::chgEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_hasEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_hasEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_hasEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_WeightedSampling_Sl_double_Sg__hasEvidence__SWIG_0((gum::WeightedSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_hasEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_hasEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_WeightedSampling_Sl_double_Sg__hasEvidence__SWIG_1((gum::WeightedSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_hasEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WeightedSampling_hasEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_hasEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_hasEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WeightedSampling_hasEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::WeightedSampling< double >::hasEvidence(gum::NodeId const) const\n"
    "    gum::WeightedSampling< double >::hasEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_eraseAllEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_eraseAllEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__eraseAllEvidence(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_eraseEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_eraseEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_eraseEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__eraseEvidence__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_eraseEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_eraseEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__eraseEvidence__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_eraseEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WeightedSampling_eraseEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_eraseEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_eraseEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WeightedSampling_eraseEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::WeightedSampling< double >::eraseEvidence(gum::NodeId const)\n"
    "    gum::WeightedSampling< double >::eraseEvidence(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_hasSoftEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_hasSoftEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_WeightedSampling_Sl_double_Sg__hasSoftEvidence__SWIG_0((gum::WeightedSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_hasHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "WeightedSampling_hasHardEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_hasHardEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_WeightedSampling_Sl_double_Sg__hasHardEvidence((gum::WeightedSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_hasSoftEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_WeightedSampling_Sl_double_Sg__hasSoftEvidence__SWIG_1((gum::WeightedSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_hasSoftEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WeightedSampling_hasSoftEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WeightedSampling_hasSoftEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::WeightedSampling< double >::hasSoftEvidence(gum::NodeId const) const\n"
    "    gum::WeightedSampling< double >::hasSoftEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_nbrEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_nbrEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = gum_WeightedSampling_Sl_double_Sg__nbrEvidence((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_nbrHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_nbrHardEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = gum_WeightedSampling_Sl_double_Sg__nbrHardEvidence((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_nbrSoftEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_nbrSoftEvidence" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = gum_WeightedSampling_Sl_double_Sg__nbrSoftEvidence((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_eraseAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_eraseAllTargets" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__eraseAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_addAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_addAllTargets" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__addAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_addTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_addTarget" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_addTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__addTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_addTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_addTarget" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__addTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_addTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WeightedSampling_addTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_addTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_addTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WeightedSampling_addTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::WeightedSampling< double >::addTarget(gum::NodeId const)\n"
    "    gum::WeightedSampling< double >::addTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_eraseTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_eraseTarget" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_eraseTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__eraseTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_eraseTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_eraseTarget" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_WeightedSampling_Sl_double_Sg__eraseTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_eraseTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WeightedSampling_eraseTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_eraseTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_eraseTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WeightedSampling_eraseTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::WeightedSampling< double >::eraseTarget(gum::NodeId const)\n"
    "    gum::WeightedSampling< double >::eraseTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_isTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_isTarget" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_isTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_WeightedSampling_Sl_double_Sg__isTarget__SWIG_0((gum::WeightedSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_isTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_isTarget" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_WeightedSampling_Sl_double_Sg__isTarget__SWIG_1((gum::WeightedSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_isTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WeightedSampling_isTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_isTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_isTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WeightedSampling_isTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::WeightedSampling< double >::isTarget(gum::NodeId const) const\n"
    "    gum::WeightedSampling< double >::isTarget(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_nbrTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_nbrTargets" "', argument " "1"" of type '" "gum::WeightedSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    try {
      result = gum_WeightedSampling_Sl_double_Sg__nbrTargets((gum::WeightedSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_H__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_H" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_H" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (double)gum_WeightedSampling_Sl_double_Sg__H__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_H__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_H" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (double)gum_WeightedSampling_Sl_double_Sg__H__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_H(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WeightedSampling_H", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_H__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_H__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WeightedSampling_H'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::WeightedSampling< double >::H(gum::NodeId const)\n"
    "    gum::WeightedSampling< double >::H(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_evidenceImpact__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_evidenceImpact" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WeightedSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_WeightedSampling_Sl_double_Sg__evidenceImpact__SWIG_1(arg1,(std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_evidenceImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WeightedSampling_evidenceImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_WeightedSampling_evidenceImpact__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_WeightedSampling_evidenceImpact__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WeightedSampling_evidenceImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::WeightedSampling< double >::evidenceImpact(gum::NodeId,PyObject *)\n"
    "    gum::WeightedSampling< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_currentPosterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_currentPosterior" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedSampling_currentPosterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Potential< double > *) &gum_WeightedSampling_Sl_double_Sg__currentPosterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_currentPosterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::WeightedSampling< double > *arg1 = (gum::WeightedSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__WeightedSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedSampling_currentPosterior" "', argument " "1"" of type '" "gum::WeightedSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::WeightedSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Potential< double > *) &gum_WeightedSampling_Sl_double_Sg__currentPosterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeightedSampling_currentPosterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WeightedSampling_currentPosterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_currentPosterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__WeightedSamplingT_double_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_WeightedSampling_currentPosterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WeightedSampling_currentPosterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::WeightedSampling< double >::currentPosterior(gum::NodeId const)\n"
    "    gum::WeightedSampling< double >::currentPosterior(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *WeightedSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__WeightedSamplingT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *WeightedSampling_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MonteCarloSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::MonteCarloSampling< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonteCarloSampling" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (gum::MonteCarloSampling< double > *)new gum::MonteCarloSampling< double >((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MonteCarloSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MonteCarloSampling" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_setEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MonteCarloSampling_setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_setEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_updateEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MonteCarloSampling_updateEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_updateEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__updateEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_setTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MonteCarloSampling_setTargets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_setTargets" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__setTargets(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_hardEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_hardEvidenceNodes" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_MonteCarloSampling_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_softEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_softEvidenceNodes" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_MonteCarloSampling_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_targets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_targets" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_MonteCarloSampling_Sl_double_Sg__targets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_evidenceImpact__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_evidenceImpact" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_evidenceImpact" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = gum_MonteCarloSampling_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_setVerbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MonteCarloSampling_setVerbosity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_setVerbosity" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_setVerbosity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__setVerbosity(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_setEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MonteCarloSampling_setEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_setEpsilon" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_setEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__setEpsilon(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_setMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MonteCarloSampling_setMinEpsilonRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_setMinEpsilonRate" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_setMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__setMinEpsilonRate(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_setMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MonteCarloSampling_setMaxIter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_setMaxIter" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_setMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__setMaxIter(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_setMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MonteCarloSampling_setMaxTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_setMaxTime" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_setMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__setMaxTime(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_setPeriodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MonteCarloSampling_setPeriodSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_setPeriodSize" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_setPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__setPeriodSize(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_verbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_verbosity" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (bool)gum_MonteCarloSampling_Sl_double_Sg__verbosity((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_epsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_epsilon" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_MonteCarloSampling_Sl_double_Sg__epsilon((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_minEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_minEpsilonRate" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_MonteCarloSampling_Sl_double_Sg__minEpsilonRate((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_maxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_maxIter" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = gum_MonteCarloSampling_Sl_double_Sg__maxIter((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_maxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_maxTime" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_MonteCarloSampling_Sl_double_Sg__maxTime((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_periodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_periodSize" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = gum_MonteCarloSampling_Sl_double_Sg__periodSize((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_nbrIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_nbrIterations" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = gum_MonteCarloSampling_Sl_double_Sg__nbrIterations((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_currentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_currentTime" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_MonteCarloSampling_Sl_double_Sg__currentTime((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_messageApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_messageApproximationScheme" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = gum_MonteCarloSampling_Sl_double_Sg__messageApproximationScheme((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_history" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_MonteCarloSampling_Sl_double_Sg__history((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_asIApproximationSchemeConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_asIApproximationSchemeConfiguration" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration *) &gum_MonteCarloSampling_Sl_double_Sg__asIApproximationSchemeConfiguration((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IApproximationSchemeConfiguration, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_makeInference" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__makeInference(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_posterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_posterior" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_posterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_MonteCarloSampling_Sl_double_Sg__posterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_posterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_posterior" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MonteCarloSampling_posterior" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_MonteCarloSampling_Sl_double_Sg__posterior__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_posterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonteCarloSampling_posterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_posterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_posterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonteCarloSampling_posterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MonteCarloSampling< double >::posterior(gum::NodeId const)\n"
    "    gum::MonteCarloSampling< double >::posterior(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_BN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_BN" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (gum::IBayesNet< double > *) &gum_MonteCarloSampling_Sl_double_Sg__BN((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_addEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_addEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonteCarloSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_addEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_addEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonteCarloSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_addEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_addEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_addEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_addEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_addEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_addEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_addEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_addEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__addEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonteCarloSampling_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonteCarloSampling_addEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MonteCarloSampling_addEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MonteCarloSampling_addEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonteCarloSampling_addEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MonteCarloSampling_addEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MonteCarloSampling_addEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonteCarloSampling_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MonteCarloSampling< double >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::MonteCarloSampling< double >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::MonteCarloSampling< double >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::MonteCarloSampling< double >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::MonteCarloSampling< double >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::MonteCarloSampling< double >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_chgEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_chgEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_chgEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_chgEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_chgEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_chgEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__chgEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_chgEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonteCarloSampling_chgEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonteCarloSampling_chgEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MonteCarloSampling_chgEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MonteCarloSampling_chgEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonteCarloSampling_chgEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MonteCarloSampling_chgEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MonteCarloSampling_chgEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonteCarloSampling_chgEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MonteCarloSampling< double >::chgEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::MonteCarloSampling< double >::chgEvidence(std::string const &,gum::Idx const)\n"
    "    gum::MonteCarloSampling< double >::chgEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::MonteCarloSampling< double >::chgEvidence(std::string const &,std::string const &)\n"
    "    gum::MonteCarloSampling< double >::chgEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::MonteCarloSampling< double >::chgEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_hasEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_hasEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_hasEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_MonteCarloSampling_Sl_double_Sg__hasEvidence__SWIG_0((gum::MonteCarloSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_hasEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_hasEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_MonteCarloSampling_Sl_double_Sg__hasEvidence__SWIG_1((gum::MonteCarloSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_hasEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonteCarloSampling_hasEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_hasEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_hasEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonteCarloSampling_hasEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MonteCarloSampling< double >::hasEvidence(gum::NodeId const) const\n"
    "    gum::MonteCarloSampling< double >::hasEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_eraseAllEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_eraseAllEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__eraseAllEvidence(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_eraseEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_eraseEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_eraseEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__eraseEvidence__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_eraseEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_eraseEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__eraseEvidence__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_eraseEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonteCarloSampling_eraseEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_eraseEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_eraseEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonteCarloSampling_eraseEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MonteCarloSampling< double >::eraseEvidence(gum::NodeId const)\n"
    "    gum::MonteCarloSampling< double >::eraseEvidence(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_hasSoftEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_hasSoftEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_MonteCarloSampling_Sl_double_Sg__hasSoftEvidence__SWIG_0((gum::MonteCarloSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_hasHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "MonteCarloSampling_hasHardEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_hasHardEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_MonteCarloSampling_Sl_double_Sg__hasHardEvidence((gum::MonteCarloSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_hasSoftEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_MonteCarloSampling_Sl_double_Sg__hasSoftEvidence__SWIG_1((gum::MonteCarloSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_hasSoftEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonteCarloSampling_hasSoftEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonteCarloSampling_hasSoftEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MonteCarloSampling< double >::hasSoftEvidence(gum::NodeId const) const\n"
    "    gum::MonteCarloSampling< double >::hasSoftEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_nbrEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_nbrEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = gum_MonteCarloSampling_Sl_double_Sg__nbrEvidence((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_nbrHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_nbrHardEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = gum_MonteCarloSampling_Sl_double_Sg__nbrHardEvidence((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_nbrSoftEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_nbrSoftEvidence" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = gum_MonteCarloSampling_Sl_double_Sg__nbrSoftEvidence((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_eraseAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_eraseAllTargets" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__eraseAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_addAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_addAllTargets" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__addAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_addTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_addTarget" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_addTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__addTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_addTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_addTarget" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__addTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_addTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonteCarloSampling_addTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_addTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_addTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonteCarloSampling_addTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MonteCarloSampling< double >::addTarget(gum::NodeId const)\n"
    "    gum::MonteCarloSampling< double >::addTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_eraseTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_eraseTarget" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_eraseTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__eraseTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_eraseTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_eraseTarget" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_MonteCarloSampling_Sl_double_Sg__eraseTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_eraseTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonteCarloSampling_eraseTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_eraseTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_eraseTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonteCarloSampling_eraseTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MonteCarloSampling< double >::eraseTarget(gum::NodeId const)\n"
    "    gum::MonteCarloSampling< double >::eraseTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_isTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_isTarget" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_isTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_MonteCarloSampling_Sl_double_Sg__isTarget__SWIG_0((gum::MonteCarloSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_isTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_isTarget" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_MonteCarloSampling_Sl_double_Sg__isTarget__SWIG_1((gum::MonteCarloSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_isTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonteCarloSampling_isTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_isTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_isTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonteCarloSampling_isTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MonteCarloSampling< double >::isTarget(gum::NodeId const) const\n"
    "    gum::MonteCarloSampling< double >::isTarget(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_nbrTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_nbrTargets" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    try {
      result = gum_MonteCarloSampling_Sl_double_Sg__nbrTargets((gum::MonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_H__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_H" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_H" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (double)gum_MonteCarloSampling_Sl_double_Sg__H__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_H__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_H" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (double)gum_MonteCarloSampling_Sl_double_Sg__H__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_H(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonteCarloSampling_H", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_H__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_H__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonteCarloSampling_H'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MonteCarloSampling< double >::H(gum::NodeId const)\n"
    "    gum::MonteCarloSampling< double >::H(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_evidenceImpact__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_evidenceImpact" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MonteCarloSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_MonteCarloSampling_Sl_double_Sg__evidenceImpact__SWIG_1(arg1,(std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_evidenceImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonteCarloSampling_evidenceImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_MonteCarloSampling_evidenceImpact__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MonteCarloSampling_evidenceImpact__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonteCarloSampling_evidenceImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MonteCarloSampling< double >::evidenceImpact(gum::NodeId,PyObject *)\n"
    "    gum::MonteCarloSampling< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_currentPosterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_currentPosterior" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonteCarloSampling_currentPosterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Potential< double > *) &gum_MonteCarloSampling_Sl_double_Sg__currentPosterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_currentPosterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::MonteCarloSampling< double > *arg1 = (gum::MonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonteCarloSampling_currentPosterior" "', argument " "1"" of type '" "gum::MonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::MonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MonteCarloSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MonteCarloSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Potential< double > *) &gum_MonteCarloSampling_Sl_double_Sg__currentPosterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonteCarloSampling_currentPosterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonteCarloSampling_currentPosterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_currentPosterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__MonteCarloSamplingT_double_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_MonteCarloSampling_currentPosterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonteCarloSampling_currentPosterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::MonteCarloSampling< double >::currentPosterior(gum::NodeId const)\n"
    "    gum::MonteCarloSampling< double >::currentPosterior(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *MonteCarloSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__MonteCarloSamplingT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MonteCarloSampling_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LoopyImportanceSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LoopyImportanceSampling" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *)new gum::LoopySamplingInference< double,gum::ImportanceSampling >((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LoopyImportanceSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LoopyImportanceSampling" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling__makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling__makeInference" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      (arg1)->_makeInference();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_setVirtualLBPSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_setVirtualLBPSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_setVirtualLBPSize" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_setVirtualLBPSize" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      (arg1)->setVirtualLBPSize(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_setEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_setEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_updateEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_updateEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_updateEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__updateEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_setTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_setTargets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_setTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setTargets(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_hardEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_hardEvidenceNodes" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_softEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_softEvidenceNodes" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_targets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_targets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__targets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_evidenceImpact__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_evidenceImpact" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_evidenceImpact" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__evidenceImpact__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_setVerbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_setVerbosity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_setVerbosity" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_setVerbosity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setVerbosity(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_setEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_setEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_setEpsilon" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_setEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setEpsilon(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_setMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_setMinEpsilonRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_setMinEpsilonRate" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_setMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setMinEpsilonRate(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_setMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_setMaxIter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_setMaxIter" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_setMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setMaxIter(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_setMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_setMaxTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_setMaxTime" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_setMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setMaxTime(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_setPeriodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_setPeriodSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_setPeriodSize" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_setPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__setPeriodSize(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_verbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_verbosity" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__verbosity((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_epsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_epsilon" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__epsilon((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_minEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_minEpsilonRate" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__minEpsilonRate((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_maxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_maxIter" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__maxIter((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_maxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_maxTime" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__maxTime((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_periodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_periodSize" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__periodSize((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_nbrIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_nbrIterations" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__nbrIterations((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_currentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_currentTime" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__currentTime((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_messageApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_messageApproximationScheme" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__messageApproximationScheme((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_history" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__history((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_asIApproximationSchemeConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_asIApproximationSchemeConfiguration" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration *) &gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__asIApproximationSchemeConfiguration((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IApproximationSchemeConfiguration, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_makeInference" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__makeInference(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_posterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_posterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_posterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__posterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_posterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_posterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LoopyImportanceSampling_posterior" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__posterior__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_posterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_posterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_posterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_posterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyImportanceSampling_posterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::posterior(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::posterior(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_BN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_BN" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = (gum::IBayesNet< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__BN((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_addEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_addEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_addEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_addEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_addEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_addEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyImportanceSampling_addEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyImportanceSampling_addEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyImportanceSampling_addEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyImportanceSampling_addEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyImportanceSampling_addEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyImportanceSampling_addEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyImportanceSampling_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_chgEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_chgEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_chgEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_chgEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_chgEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_chgEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__chgEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_chgEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_chgEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyImportanceSampling_chgEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyImportanceSampling_chgEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyImportanceSampling_chgEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyImportanceSampling_chgEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyImportanceSampling_chgEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyImportanceSampling_chgEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyImportanceSampling_chgEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::chgEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::chgEvidence(std::string const &,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::chgEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::chgEvidence(std::string const &,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::chgEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::chgEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_hasEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_hasEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_hasEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__hasEvidence__SWIG_0((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_hasEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_hasEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__hasEvidence__SWIG_1((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_hasEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_hasEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_hasEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_hasEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyImportanceSampling_hasEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::hasEvidence(gum::NodeId const) const\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::hasEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_eraseAllEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_eraseAllEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__eraseAllEvidence(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_eraseEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_eraseEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_eraseEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__eraseEvidence__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_eraseEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_eraseEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__eraseEvidence__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_eraseEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_eraseEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_eraseEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_eraseEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyImportanceSampling_eraseEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::eraseEvidence(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::eraseEvidence(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_hasSoftEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_hasSoftEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__hasSoftEvidence__SWIG_0((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_hasHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_hasHardEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_hasHardEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__hasHardEvidence((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_hasSoftEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__hasSoftEvidence__SWIG_1((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_hasSoftEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_hasSoftEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyImportanceSampling_hasSoftEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::hasSoftEvidence(gum::NodeId const) const\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::hasSoftEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_nbrEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_nbrEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__nbrEvidence((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_nbrHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_nbrHardEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__nbrHardEvidence((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_nbrSoftEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_nbrSoftEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__nbrSoftEvidence((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_eraseAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_eraseAllTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__eraseAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_addAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_addAllTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_addTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_addTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_addTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_addTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_addTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__addTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_addTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_addTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_addTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_addTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyImportanceSampling_addTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::addTarget(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::addTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_eraseTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_eraseTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_eraseTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__eraseTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_eraseTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_eraseTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__eraseTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_eraseTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_eraseTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_eraseTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_eraseTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyImportanceSampling_eraseTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::eraseTarget(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::eraseTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_isTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_isTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_isTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__isTarget__SWIG_0((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_isTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_isTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__isTarget__SWIG_1((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_isTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_isTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_isTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_isTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyImportanceSampling_isTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::isTarget(gum::NodeId const) const\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::isTarget(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_nbrTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_nbrTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__nbrTargets((gum::LoopySamplingInference< double,gum::ImportanceSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_H__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_H" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_H" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__H__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_H__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_H" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__H__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_H(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_H", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_H__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_H__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyImportanceSampling_H'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::H(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::H(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_evidenceImpact__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_evidenceImpact" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyImportanceSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__evidenceImpact__SWIG_1(arg1,(std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_evidenceImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_evidenceImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_LoopyImportanceSampling_evidenceImpact__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyImportanceSampling_evidenceImpact__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyImportanceSampling_evidenceImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::evidenceImpact(gum::NodeId,PyObject *)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_currentPosterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_currentPosterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyImportanceSampling_currentPosterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Potential< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__currentPosterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_currentPosterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::ImportanceSampling > *arg1 = (gum::LoopySamplingInference< double,gum::ImportanceSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyImportanceSampling_currentPosterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::ImportanceSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::ImportanceSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyImportanceSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyImportanceSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Potential< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_ImportanceSampling_Sg__currentPosterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyImportanceSampling_currentPosterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyImportanceSampling_currentPosterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_currentPosterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_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_LoopyImportanceSampling_currentPosterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyImportanceSampling_currentPosterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::currentPosterior(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::ImportanceSampling >::currentPosterior(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *LoopyImportanceSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LoopyImportanceSampling_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LoopyWeightedSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LoopyWeightedSampling" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (gum::LoopySamplingInference< double,gum::WeightedSampling > *)new gum::LoopySamplingInference< double,gum::WeightedSampling >((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LoopyWeightedSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LoopyWeightedSampling" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling__makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling__makeInference" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      (arg1)->_makeInference();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_setVirtualLBPSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_setVirtualLBPSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_setVirtualLBPSize" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_setVirtualLBPSize" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      (arg1)->setVirtualLBPSize(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_setEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_setEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_updateEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_updateEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_updateEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__updateEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_setTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_setTargets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_setTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setTargets(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_hardEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_hardEvidenceNodes" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_softEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_softEvidenceNodes" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_targets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_targets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__targets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_evidenceImpact__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_evidenceImpact" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_evidenceImpact" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__evidenceImpact__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_setVerbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_setVerbosity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_setVerbosity" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_setVerbosity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setVerbosity(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_setEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_setEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_setEpsilon" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_setEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setEpsilon(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_setMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_setMinEpsilonRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_setMinEpsilonRate" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_setMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setMinEpsilonRate(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_setMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_setMaxIter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_setMaxIter" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_setMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setMaxIter(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_setMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_setMaxTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_setMaxTime" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_setMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setMaxTime(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_setPeriodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_setPeriodSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_setPeriodSize" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_setPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__setPeriodSize(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_verbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_verbosity" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__verbosity((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_epsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_epsilon" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__epsilon((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_minEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_minEpsilonRate" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__minEpsilonRate((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_maxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_maxIter" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__maxIter((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_maxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_maxTime" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__maxTime((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_periodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_periodSize" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__periodSize((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_nbrIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_nbrIterations" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__nbrIterations((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_currentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_currentTime" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__currentTime((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_messageApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_messageApproximationScheme" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__messageApproximationScheme((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_history" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__history((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_asIApproximationSchemeConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_asIApproximationSchemeConfiguration" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration *) &gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__asIApproximationSchemeConfiguration((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IApproximationSchemeConfiguration, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_makeInference" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__makeInference(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_posterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_posterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_posterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__posterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_posterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_posterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LoopyWeightedSampling_posterior" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__posterior__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_posterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_posterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_posterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_posterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyWeightedSampling_posterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::posterior(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::posterior(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_BN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_BN" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = (gum::IBayesNet< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__BN((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_addEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_addEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_addEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_addEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_addEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_addEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyWeightedSampling_addEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyWeightedSampling_addEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyWeightedSampling_addEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyWeightedSampling_addEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyWeightedSampling_addEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyWeightedSampling_addEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyWeightedSampling_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_chgEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_chgEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_chgEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_chgEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_chgEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_chgEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__chgEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_chgEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_chgEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyWeightedSampling_chgEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyWeightedSampling_chgEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyWeightedSampling_chgEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyWeightedSampling_chgEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyWeightedSampling_chgEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyWeightedSampling_chgEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyWeightedSampling_chgEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::chgEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::chgEvidence(std::string const &,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::chgEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::chgEvidence(std::string const &,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::chgEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::chgEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_hasEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_hasEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_hasEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__hasEvidence__SWIG_0((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_hasEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_hasEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__hasEvidence__SWIG_1((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_hasEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_hasEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_hasEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_hasEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyWeightedSampling_hasEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::hasEvidence(gum::NodeId const) const\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::hasEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_eraseAllEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_eraseAllEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__eraseAllEvidence(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_eraseEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_eraseEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_eraseEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__eraseEvidence__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_eraseEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_eraseEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__eraseEvidence__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_eraseEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_eraseEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_eraseEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_eraseEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyWeightedSampling_eraseEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::eraseEvidence(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::eraseEvidence(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_hasSoftEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_hasSoftEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__hasSoftEvidence__SWIG_0((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_hasHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_hasHardEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_hasHardEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__hasHardEvidence((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_hasSoftEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__hasSoftEvidence__SWIG_1((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_hasSoftEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_hasSoftEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyWeightedSampling_hasSoftEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::hasSoftEvidence(gum::NodeId const) const\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::hasSoftEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_nbrEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_nbrEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__nbrEvidence((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_nbrHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_nbrHardEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__nbrHardEvidence((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_nbrSoftEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_nbrSoftEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__nbrSoftEvidence((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_eraseAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_eraseAllTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__eraseAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_addAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_addAllTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_addTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_addTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_addTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_addTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_addTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__addTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_addTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_addTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_addTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_addTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyWeightedSampling_addTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::addTarget(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::addTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_eraseTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_eraseTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_eraseTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__eraseTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_eraseTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_eraseTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__eraseTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_eraseTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_eraseTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_eraseTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_eraseTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyWeightedSampling_eraseTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::eraseTarget(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::eraseTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_isTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_isTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_isTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__isTarget__SWIG_0((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_isTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_isTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__isTarget__SWIG_1((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_isTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_isTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_isTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_isTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyWeightedSampling_isTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::isTarget(gum::NodeId const) const\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::isTarget(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_nbrTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_nbrTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__nbrTargets((gum::LoopySamplingInference< double,gum::WeightedSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_H__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_H" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_H" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__H__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_H__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_H" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__H__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_H(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_H", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_H__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_H__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyWeightedSampling_H'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::H(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::H(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_evidenceImpact__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_evidenceImpact" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyWeightedSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__evidenceImpact__SWIG_1(arg1,(std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_evidenceImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_evidenceImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_LoopyWeightedSampling_evidenceImpact__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyWeightedSampling_evidenceImpact__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyWeightedSampling_evidenceImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::evidenceImpact(gum::NodeId,PyObject *)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_currentPosterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_currentPosterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyWeightedSampling_currentPosterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Potential< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__currentPosterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_currentPosterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::WeightedSampling > *arg1 = (gum::LoopySamplingInference< double,gum::WeightedSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyWeightedSampling_currentPosterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::WeightedSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::WeightedSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyWeightedSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyWeightedSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Potential< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_WeightedSampling_Sg__currentPosterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyWeightedSampling_currentPosterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyWeightedSampling_currentPosterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_currentPosterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_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_LoopyWeightedSampling_currentPosterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyWeightedSampling_currentPosterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::currentPosterior(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::WeightedSampling >::currentPosterior(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *LoopyWeightedSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LoopyWeightedSampling_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LoopyGibbsSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LoopyGibbsSampling" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (gum::LoopySamplingInference< double,gum::GibbsSampling > *)new gum::LoopySamplingInference< double,gum::GibbsSampling >((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LoopyGibbsSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LoopyGibbsSampling" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling__makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling__makeInference" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      (arg1)->_makeInference();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_setVirtualLBPSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_setVirtualLBPSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_setVirtualLBPSize" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_setVirtualLBPSize" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      (arg1)->setVirtualLBPSize(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_setEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_setEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_updateEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_updateEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_updateEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__updateEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_setTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_setTargets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_setTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setTargets(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_hardEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_hardEvidenceNodes" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_softEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_softEvidenceNodes" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_targets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_targets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__targets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_evidenceImpact__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_evidenceImpact" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_evidenceImpact" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__evidenceImpact__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_setVerbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_setVerbosity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_setVerbosity" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_setVerbosity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setVerbosity(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_setEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_setEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_setEpsilon" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_setEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setEpsilon(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_setMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_setMinEpsilonRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_setMinEpsilonRate" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_setMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setMinEpsilonRate(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_setMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_setMaxIter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_setMaxIter" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_setMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setMaxIter(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_setMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_setMaxTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_setMaxTime" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_setMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setMaxTime(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_setPeriodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_setPeriodSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_setPeriodSize" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_setPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setPeriodSize(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_verbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_verbosity" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__verbosity((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_epsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_epsilon" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__epsilon((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_minEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_minEpsilonRate" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__minEpsilonRate((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_maxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_maxIter" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__maxIter((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_maxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_maxTime" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__maxTime((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_periodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_periodSize" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__periodSize((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_nbrIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_nbrIterations" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__nbrIterations((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_currentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_currentTime" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__currentTime((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_messageApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_messageApproximationScheme" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__messageApproximationScheme((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_history" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__history((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_asIApproximationSchemeConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_asIApproximationSchemeConfiguration" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration *) &gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__asIApproximationSchemeConfiguration((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IApproximationSchemeConfiguration, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_makeInference" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__makeInference(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_posterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_posterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_posterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__posterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_posterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_posterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LoopyGibbsSampling_posterior" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__posterior__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_posterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_posterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_posterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_posterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyGibbsSampling_posterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::posterior(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::posterior(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_BN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_BN" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = (gum::IBayesNet< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__BN((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_addEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_addEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_addEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_addEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_addEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_addEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyGibbsSampling_addEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyGibbsSampling_addEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyGibbsSampling_addEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyGibbsSampling_addEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyGibbsSampling_addEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyGibbsSampling_addEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyGibbsSampling_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_chgEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_chgEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_chgEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_chgEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_chgEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_chgEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__chgEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_chgEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_chgEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyGibbsSampling_chgEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyGibbsSampling_chgEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyGibbsSampling_chgEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyGibbsSampling_chgEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyGibbsSampling_chgEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyGibbsSampling_chgEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyGibbsSampling_chgEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::chgEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::chgEvidence(std::string const &,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::chgEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::chgEvidence(std::string const &,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::chgEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::chgEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_hasEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_hasEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_hasEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__hasEvidence__SWIG_0((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_hasEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_hasEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__hasEvidence__SWIG_1((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_hasEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_hasEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_hasEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_hasEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyGibbsSampling_hasEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::hasEvidence(gum::NodeId const) const\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::hasEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_eraseAllEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_eraseAllEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__eraseAllEvidence(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_eraseEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_eraseEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_eraseEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__eraseEvidence__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_eraseEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_eraseEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__eraseEvidence__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_eraseEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_eraseEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_eraseEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_eraseEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyGibbsSampling_eraseEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::eraseEvidence(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::eraseEvidence(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_hasSoftEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_hasSoftEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__hasSoftEvidence__SWIG_0((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_hasHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_hasHardEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_hasHardEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__hasHardEvidence((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_hasSoftEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__hasSoftEvidence__SWIG_1((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_hasSoftEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_hasSoftEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyGibbsSampling_hasSoftEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::hasSoftEvidence(gum::NodeId const) const\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::hasSoftEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_nbrEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_nbrEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__nbrEvidence((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_nbrHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_nbrHardEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__nbrHardEvidence((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_nbrSoftEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_nbrSoftEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__nbrSoftEvidence((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_eraseAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_eraseAllTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__eraseAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_addAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_addAllTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_addTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_addTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_addTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_addTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_addTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__addTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_addTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_addTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_addTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_addTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyGibbsSampling_addTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::addTarget(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::addTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_eraseTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_eraseTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_eraseTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__eraseTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_eraseTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_eraseTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__eraseTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_eraseTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_eraseTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_eraseTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_eraseTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyGibbsSampling_eraseTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::eraseTarget(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::eraseTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_isTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_isTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_isTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__isTarget__SWIG_0((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_isTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_isTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__isTarget__SWIG_1((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_isTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_isTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_isTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_isTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyGibbsSampling_isTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::isTarget(gum::NodeId const) const\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::isTarget(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_nbrTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_nbrTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__nbrTargets((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_H__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_H" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_H" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__H__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_H__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_H" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__H__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_H(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_H", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_H__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_H__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyGibbsSampling_H'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::H(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::H(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_evidenceImpact__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_evidenceImpact" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyGibbsSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__evidenceImpact__SWIG_1(arg1,(std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_evidenceImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_evidenceImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_LoopyGibbsSampling_evidenceImpact__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyGibbsSampling_evidenceImpact__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyGibbsSampling_evidenceImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::evidenceImpact(gum::NodeId,PyObject *)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_currentPosterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_currentPosterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_currentPosterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Potential< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__currentPosterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_currentPosterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_currentPosterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyGibbsSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyGibbsSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Potential< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__currentPosterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_currentPosterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_currentPosterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_currentPosterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_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_LoopyGibbsSampling_currentPosterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyGibbsSampling_currentPosterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::currentPosterior(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::GibbsSampling >::currentPosterior(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_nbrDrawnVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_nbrDrawnVar" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__nbrDrawnVar((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_setNbrDrawnVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_setNbrDrawnVar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_setNbrDrawnVar" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_setNbrDrawnVar" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setNbrDrawnVar(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_isDrawnAtRandom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_isDrawnAtRandom" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__isDrawnAtRandom((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_setDrawnAtRandom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_setDrawnAtRandom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_setDrawnAtRandom" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_setDrawnAtRandom" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setDrawnAtRandom(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_burnIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_burnIn" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__burnIn((gum::LoopySamplingInference< double,gum::GibbsSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyGibbsSampling_setBurnIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::GibbsSampling > *arg1 = (gum::LoopySamplingInference< double,gum::GibbsSampling > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyGibbsSampling_setBurnIn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyGibbsSampling_setBurnIn" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::GibbsSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::GibbsSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyGibbsSampling_setBurnIn" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_GibbsSampling_Sg__setBurnIn(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LoopyGibbsSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LoopyGibbsSampling_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LoopyMonteCarloSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LoopyMonteCarloSampling" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *)new gum::LoopySamplingInference< double,gum::MonteCarloSampling >((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LoopyMonteCarloSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LoopyMonteCarloSampling" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling__makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling__makeInference" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      (arg1)->_makeInference();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_setVirtualLBPSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_setVirtualLBPSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_setVirtualLBPSize" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_setVirtualLBPSize" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      (arg1)->setVirtualLBPSize(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_setEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_setEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_updateEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_updateEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_updateEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__updateEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_setTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_setTargets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_setTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setTargets(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_hardEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_hardEvidenceNodes" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_softEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_softEvidenceNodes" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_targets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_targets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__targets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_evidenceImpact__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_evidenceImpact" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_evidenceImpact" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__evidenceImpact__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_setVerbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_setVerbosity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_setVerbosity" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_setVerbosity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setVerbosity(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_setEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_setEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_setEpsilon" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_setEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setEpsilon(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_setMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_setMinEpsilonRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_setMinEpsilonRate" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_setMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setMinEpsilonRate(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_setMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_setMaxIter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_setMaxIter" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_setMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setMaxIter(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_setMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_setMaxTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_setMaxTime" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_setMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setMaxTime(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_setPeriodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_setPeriodSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_setPeriodSize" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_setPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__setPeriodSize(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_verbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_verbosity" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__verbosity((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_epsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_epsilon" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__epsilon((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_minEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_minEpsilonRate" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__minEpsilonRate((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_maxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_maxIter" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__maxIter((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_maxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_maxTime" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__maxTime((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_periodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_periodSize" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__periodSize((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_nbrIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_nbrIterations" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__nbrIterations((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_currentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_currentTime" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__currentTime((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_messageApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_messageApproximationScheme" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__messageApproximationScheme((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_history" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__history((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_asIApproximationSchemeConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_asIApproximationSchemeConfiguration" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration *) &gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__asIApproximationSchemeConfiguration((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IApproximationSchemeConfiguration, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_makeInference" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__makeInference(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_posterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_posterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_posterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__posterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_posterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_posterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LoopyMonteCarloSampling_posterior" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__posterior__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_posterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_posterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_posterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_posterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyMonteCarloSampling_posterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::posterior(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::posterior(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_BN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_BN" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = (gum::IBayesNet< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__BN((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_addEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_addEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_addEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_addEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_addEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_addEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyMonteCarloSampling_addEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyMonteCarloSampling_addEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyMonteCarloSampling_addEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyMonteCarloSampling_addEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyMonteCarloSampling_addEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyMonteCarloSampling_addEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyMonteCarloSampling_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__chgEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_chgEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_chgEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyMonteCarloSampling_chgEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyMonteCarloSampling_chgEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::chgEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::chgEvidence(std::string const &,gum::Idx const)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::chgEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::chgEvidence(std::string const &,std::string const &)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::chgEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::chgEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_hasEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_hasEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_hasEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__hasEvidence__SWIG_0((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_hasEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_hasEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__hasEvidence__SWIG_1((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_hasEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_hasEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_hasEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_hasEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyMonteCarloSampling_hasEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::hasEvidence(gum::NodeId const) const\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::hasEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_eraseAllEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_eraseAllEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__eraseAllEvidence(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_eraseEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_eraseEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_eraseEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__eraseEvidence__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_eraseEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_eraseEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__eraseEvidence__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_eraseEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_eraseEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_eraseEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_eraseEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyMonteCarloSampling_eraseEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::eraseEvidence(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::eraseEvidence(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_hasSoftEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_hasSoftEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__hasSoftEvidence__SWIG_0((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_hasHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_hasHardEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_hasHardEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__hasHardEvidence((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_hasSoftEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_hasSoftEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__hasSoftEvidence__SWIG_1((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_hasSoftEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_hasSoftEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_hasSoftEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_hasSoftEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyMonteCarloSampling_hasSoftEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::hasSoftEvidence(gum::NodeId const) const\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::hasSoftEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_nbrEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_nbrEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__nbrEvidence((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_nbrHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_nbrHardEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__nbrHardEvidence((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_nbrSoftEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_nbrSoftEvidence" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__nbrSoftEvidence((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_eraseAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_eraseAllTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__eraseAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_addAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_addAllTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_addTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_addTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_addTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_addTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_addTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__addTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_addTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_addTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_addTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_addTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyMonteCarloSampling_addTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::addTarget(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::addTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_eraseTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_eraseTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_eraseTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__eraseTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_eraseTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_eraseTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__eraseTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_eraseTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_eraseTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_eraseTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_eraseTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyMonteCarloSampling_eraseTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::eraseTarget(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::eraseTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_isTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_isTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_isTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__isTarget__SWIG_0((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_isTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_isTarget" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__isTarget__SWIG_1((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_isTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_isTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_isTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_isTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyMonteCarloSampling_isTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::isTarget(gum::NodeId const) const\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::isTarget(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_nbrTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_nbrTargets" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__nbrTargets((gum::LoopySamplingInference< double,gum::MonteCarloSampling > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_H__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_H" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_H" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__H__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_H__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_H" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (double)gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__H__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_H(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_H", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_H__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_H__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyMonteCarloSampling_H'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::H(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::H(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_evidenceImpact__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_evidenceImpact" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyMonteCarloSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__evidenceImpact__SWIG_1(arg1,(std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_evidenceImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_evidenceImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_LoopyMonteCarloSampling_evidenceImpact__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyMonteCarloSampling_evidenceImpact__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyMonteCarloSampling_evidenceImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::evidenceImpact(gum::NodeId,PyObject *)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_currentPosterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_currentPosterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyMonteCarloSampling_currentPosterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Potential< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__currentPosterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_currentPosterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopySamplingInference< double,gum::MonteCarloSampling > *arg1 = (gum::LoopySamplingInference< double,gum::MonteCarloSampling > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Potential< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyMonteCarloSampling_currentPosterior" "', argument " "1"" of type '" "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopySamplingInference< double,gum::MonteCarloSampling > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyMonteCarloSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyMonteCarloSampling_currentPosterior" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::Potential< double > *) &gum_LoopySamplingInference_Sl_double_Sc_gum_MonteCarloSampling_Sg__currentPosterior__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyMonteCarloSampling_currentPosterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyMonteCarloSampling_currentPosterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_currentPosterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_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_LoopyMonteCarloSampling_currentPosterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyMonteCarloSampling_currentPosterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::currentPosterior(gum::NodeId const)\n"
    "    gum::LoopySamplingInference< double,gum::MonteCarloSampling >::currentPosterior(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *LoopyMonteCarloSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LoopyMonteCarloSampling_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LoopyBeliefPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = (gum::IBayesNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::LoopyBeliefPropagation< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LoopyBeliefPropagation" "', argument " "1"" of type '" "gum::IBayesNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  {
    try {
      result = (gum::LoopyBeliefPropagation< double > *)new gum::LoopyBeliefPropagation< double >((gum::IBayesNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LoopyBeliefPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LoopyBeliefPropagation" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_setEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_setEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_updateEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_updateEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_updateEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__updateEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_setTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_setTargets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_setTargets" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__setTargets(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_hardEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_hardEvidenceNodes" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LoopyBeliefPropagation_Sl_double_Sg__hardEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_softEvidenceNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_softEvidenceNodes" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LoopyBeliefPropagation_Sl_double_Sg__softEvidenceNodes(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_targets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_targets" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_LoopyBeliefPropagation_Sl_double_Sg__targets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_evidenceImpact__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_evidenceImpact" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_evidenceImpact" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = gum_LoopyBeliefPropagation_Sl_double_Sg__evidenceImpact__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_setVerbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_setVerbosity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_setVerbosity" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_setVerbosity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__setVerbosity(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_setEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_setEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_setEpsilon" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_setEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__setEpsilon(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_setMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_setMinEpsilonRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_setMinEpsilonRate" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_setMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__setMinEpsilonRate(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_setMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_setMaxIter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_setMaxIter" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_setMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__setMaxIter(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_setMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_setMaxTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_setMaxTime" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_setMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__setMaxTime(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_setPeriodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_setPeriodSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_setPeriodSize" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_setPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__setPeriodSize(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_verbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_verbosity" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = (bool)gum_LoopyBeliefPropagation_Sl_double_Sg__verbosity((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_epsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_epsilon" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = (double)gum_LoopyBeliefPropagation_Sl_double_Sg__epsilon((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_minEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_minEpsilonRate" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = (double)gum_LoopyBeliefPropagation_Sl_double_Sg__minEpsilonRate((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_maxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_maxIter" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = gum_LoopyBeliefPropagation_Sl_double_Sg__maxIter((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_maxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_maxTime" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = (double)gum_LoopyBeliefPropagation_Sl_double_Sg__maxTime((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_periodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_periodSize" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = gum_LoopyBeliefPropagation_Sl_double_Sg__periodSize((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_nbrIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_nbrIterations" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = gum_LoopyBeliefPropagation_Sl_double_Sg__nbrIterations((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_currentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_currentTime" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = (double)gum_LoopyBeliefPropagation_Sl_double_Sg__currentTime((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_messageApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_messageApproximationScheme" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = gum_LoopyBeliefPropagation_Sl_double_Sg__messageApproximationScheme((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_history" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_LoopyBeliefPropagation_Sl_double_Sg__history((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_asIApproximationSchemeConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_asIApproximationSchemeConfiguration" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration *) &gum_LoopyBeliefPropagation_Sl_double_Sg__asIApproximationSchemeConfiguration((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IApproximationSchemeConfiguration, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_makeInference" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__makeInference(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_posterior__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_posterior" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_posterior" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = gum_LoopyBeliefPropagation_Sl_double_Sg__posterior__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_posterior__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::Potential< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_posterior" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LoopyBeliefPropagation_posterior" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = gum_LoopyBeliefPropagation_Sl_double_Sg__posterior__SWIG_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_posterior(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_posterior", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_posterior__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_posterior__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyBeliefPropagation_posterior'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopyBeliefPropagation< double >::posterior(gum::NodeId const)\n"
    "    gum::LoopyBeliefPropagation< double >::posterior(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_BN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IBayesNet< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_BN" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = (gum::IBayesNet< double > *) &gum_LoopyBeliefPropagation_Sl_double_Sg__BN((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IBayesNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_addEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__addEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_addEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__addEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_addEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__addEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_addEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__addEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_addEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__addEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_addEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_addEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__addEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_addEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_addEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyBeliefPropagation_addEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyBeliefPropagation_addEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyBeliefPropagation_addEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyBeliefPropagation_addEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyBeliefPropagation_addEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyBeliefPropagation_addEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyBeliefPropagation_addEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopyBeliefPropagation< double >::addEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::LoopyBeliefPropagation< double >::addEvidence(std::string const &,gum::Idx const)\n"
    "    gum::LoopyBeliefPropagation< double >::addEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::LoopyBeliefPropagation< double >::addEvidence(std::string const &,std::string const &)\n"
    "    gum::LoopyBeliefPropagation< double >::addEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::LoopyBeliefPropagation< double >::addEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_chgEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_chgEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Idx arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  arg3 = static_cast< gum::Idx >(val3);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_chgEvidence__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_2(arg1,arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_chgEvidence__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_3(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_chgEvidence__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_4(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_chgEvidence__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_chgEvidence" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__chgEvidence__SWIG_5(arg1,(std::string const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_chgEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_chgEvidence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyBeliefPropagation_chgEvidence__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyBeliefPropagation_chgEvidence__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyBeliefPropagation_chgEvidence__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LoopyBeliefPropagation_chgEvidence__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyBeliefPropagation_chgEvidence__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyBeliefPropagation_chgEvidence__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyBeliefPropagation_chgEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopyBeliefPropagation< double >::chgEvidence(gum::NodeId const,gum::Idx const)\n"
    "    gum::LoopyBeliefPropagation< double >::chgEvidence(std::string const &,gum::Idx const)\n"
    "    gum::LoopyBeliefPropagation< double >::chgEvidence(gum::NodeId const,std::string const &)\n"
    "    gum::LoopyBeliefPropagation< double >::chgEvidence(std::string const &,std::string const &)\n"
    "    gum::LoopyBeliefPropagation< double >::chgEvidence(gum::NodeId const,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::LoopyBeliefPropagation< double >::chgEvidence(std::string const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_hasEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_hasEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_hasEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LoopyBeliefPropagation_Sl_double_Sg__hasEvidence__SWIG_0((gum::LoopyBeliefPropagation< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_hasEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_hasEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_hasEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopyBeliefPropagation_Sl_double_Sg__hasEvidence__SWIG_1((gum::LoopyBeliefPropagation< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_hasEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_hasEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_hasEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_hasEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyBeliefPropagation_hasEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopyBeliefPropagation< double >::hasEvidence(gum::NodeId const) const\n"
    "    gum::LoopyBeliefPropagation< double >::hasEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_eraseAllEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_eraseAllEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__eraseAllEvidence(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_eraseEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_eraseEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_eraseEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__eraseEvidence__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_eraseEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_eraseEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_eraseEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__eraseEvidence__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_eraseEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_eraseEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_eraseEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_eraseEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyBeliefPropagation_eraseEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopyBeliefPropagation< double >::eraseEvidence(gum::NodeId const)\n"
    "    gum::LoopyBeliefPropagation< double >::eraseEvidence(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_hasSoftEvidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_hasSoftEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_hasSoftEvidence" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LoopyBeliefPropagation_Sl_double_Sg__hasSoftEvidence__SWIG_0((gum::LoopyBeliefPropagation< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_hasHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_hasHardEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_hasHardEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_hasHardEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopyBeliefPropagation_Sl_double_Sg__hasHardEvidence((gum::LoopyBeliefPropagation< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_hasSoftEvidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_hasSoftEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_hasSoftEvidence" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopyBeliefPropagation_Sl_double_Sg__hasSoftEvidence__SWIG_1((gum::LoopyBeliefPropagation< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_hasSoftEvidence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_hasSoftEvidence", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_hasSoftEvidence__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_hasSoftEvidence__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyBeliefPropagation_hasSoftEvidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopyBeliefPropagation< double >::hasSoftEvidence(gum::NodeId const) const\n"
    "    gum::LoopyBeliefPropagation< double >::hasSoftEvidence(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_nbrEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_nbrEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = gum_LoopyBeliefPropagation_Sl_double_Sg__nbrEvidence((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_nbrHardEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_nbrHardEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = gum_LoopyBeliefPropagation_Sl_double_Sg__nbrHardEvidence((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_nbrSoftEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_nbrSoftEvidence" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = gum_LoopyBeliefPropagation_Sl_double_Sg__nbrSoftEvidence((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_eraseAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_eraseAllTargets" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__eraseAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_addAllTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_addAllTargets" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__addAllTargets(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_addTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_addTarget" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_addTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__addTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_addTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_addTarget" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__addTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_addTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_addTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_addTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_addTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyBeliefPropagation_addTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopyBeliefPropagation< double >::addTarget(gum::NodeId const)\n"
    "    gum::LoopyBeliefPropagation< double >::addTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_eraseTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_eraseTarget" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_eraseTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__eraseTarget__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_eraseTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_eraseTarget" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_eraseTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_LoopyBeliefPropagation_Sl_double_Sg__eraseTarget__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_eraseTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_eraseTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_eraseTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_eraseTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyBeliefPropagation_eraseTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopyBeliefPropagation< double >::eraseTarget(gum::NodeId const)\n"
    "    gum::LoopyBeliefPropagation< double >::eraseTarget(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_isTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_isTarget" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_isTarget" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)gum_LoopyBeliefPropagation_Sl_double_Sg__isTarget__SWIG_0((gum::LoopyBeliefPropagation< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_isTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_isTarget" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_isTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)gum_LoopyBeliefPropagation_Sl_double_Sg__isTarget__SWIG_1((gum::LoopyBeliefPropagation< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_isTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_isTarget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_isTarget__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_isTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyBeliefPropagation_isTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopyBeliefPropagation< double >::isTarget(gum::NodeId const) const\n"
    "    gum::LoopyBeliefPropagation< double >::isTarget(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_nbrTargets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_nbrTargets" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    try {
      result = gum_LoopyBeliefPropagation_Sl_double_Sg__nbrTargets((gum::LoopyBeliefPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_H__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_H" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoopyBeliefPropagation_H" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (double)gum_LoopyBeliefPropagation_Sl_double_Sg__H__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_H__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_H" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_H" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (double)gum_LoopyBeliefPropagation_Sl_double_Sg__H__SWIG_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_H(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_H", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_H__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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_LoopyBeliefPropagation_H__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyBeliefPropagation_H'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopyBeliefPropagation< double >::H(gum::NodeId const)\n"
    "    gum::LoopyBeliefPropagation< double >::H(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_evidenceImpact__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::LoopyBeliefPropagation< double > *arg1 = (gum::LoopyBeliefPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  gum::Potential< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoopyBeliefPropagation_evidenceImpact" "', argument " "1"" of type '" "gum::LoopyBeliefPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::LoopyBeliefPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoopyBeliefPropagation_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_evidenceImpact" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoopyBeliefPropagation_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoopyBeliefPropagation_evidenceImpact" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = gum_LoopyBeliefPropagation_Sl_double_Sg__evidenceImpact__SWIG_1(arg1,(std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Potential< double >(static_cast< const gum::Potential< double >& >(result))), SWIGTYPE_p_gum__PotentialT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LoopyBeliefPropagation_evidenceImpact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LoopyBeliefPropagation_evidenceImpact", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_LoopyBeliefPropagation_evidenceImpact__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_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::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LoopyBeliefPropagation_evidenceImpact__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LoopyBeliefPropagation_evidenceImpact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::LoopyBeliefPropagation< double >::evidenceImpact(gum::NodeId,PyObject *)\n"
    "    gum::LoopyBeliefPropagation< double >::evidenceImpact(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *LoopyBeliefPropagation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__LoopyBeliefPropagationT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LoopyBeliefPropagation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ExactBNdistance__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::IBayesNet< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::ExactBNdistance< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__IBayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExactBNdistance" "', argument " "1"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExactBNdistance" "', argument " "1"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__IBayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ExactBNdistance" "', argument " "2"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExactBNdistance" "', argument " "2"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::IBayesNet< double > * >(argp2);
  {
    try {
      result = (gum::ExactBNdistance< double > *)new gum::ExactBNdistance< double >((gum::IBayesNet< double > const &)*arg1,(gum::IBayesNet< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ExactBNdistanceT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExactBNdistance__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::ExactBNdistance< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__BNdistanceT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExactBNdistance" "', argument " "1"" of type '" "gum::BNdistance< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExactBNdistance" "', argument " "1"" of type '" "gum::BNdistance< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::BNdistance< double > * >(argp1);
  {
    try {
      result = (gum::ExactBNdistance< double > *)new gum::ExactBNdistance< double >((gum::BNdistance< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__ExactBNdistanceT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExactBNdistance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ExactBNdistance", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__BNdistanceT_double_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExactBNdistance__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__IBayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__IBayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ExactBNdistance__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ExactBNdistance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::ExactBNdistance< double >::ExactBNdistance(gum::IBayesNet< double > const &,gum::IBayesNet< double > const &)\n"
    "    gum::ExactBNdistance< double >::ExactBNdistance(gum::BNdistance< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExactBNdistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ExactBNdistance< double > *arg1 = (gum::ExactBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ExactBNdistanceT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExactBNdistance" "', argument " "1"" of type '" "gum::ExactBNdistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ExactBNdistance< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExactBNdistance_compute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::ExactBNdistance< double > *arg1 = (gum::ExactBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__ExactBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExactBNdistance_compute" "', argument " "1"" of type '" "gum::ExactBNdistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::ExactBNdistance< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_ExactBNdistance_Sl_double_Sg__compute(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExactBNdistance_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__ExactBNdistanceT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ExactBNdistance_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GibbsBNdistance__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::IBayesNet< double > *arg1 = 0 ;
  gum::IBayesNet< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::GibbsBNdistance< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__IBayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GibbsBNdistance" "', argument " "1"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GibbsBNdistance" "', argument " "1"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::IBayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__IBayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GibbsBNdistance" "', argument " "2"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GibbsBNdistance" "', argument " "2"" of type '" "gum::IBayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::IBayesNet< double > * >(argp2);
  {
    try {
      result = (gum::GibbsBNdistance< double > *)new gum::GibbsBNdistance< double >((gum::IBayesNet< double > const &)*arg1,(gum::IBayesNet< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GibbsBNdistance__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BNdistance< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::GibbsBNdistance< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__BNdistanceT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GibbsBNdistance" "', argument " "1"" of type '" "gum::BNdistance< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GibbsBNdistance" "', argument " "1"" of type '" "gum::BNdistance< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::BNdistance< double > * >(argp1);
  {
    try {
      result = (gum::GibbsBNdistance< double > *)new gum::GibbsBNdistance< double >((gum::BNdistance< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GibbsBNdistance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GibbsBNdistance", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__BNdistanceT_double_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GibbsBNdistance__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__IBayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__IBayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_GibbsBNdistance__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GibbsBNdistance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::GibbsBNdistance< double >::GibbsBNdistance(gum::IBayesNet< double > const &,gum::IBayesNet< double > const &)\n"
    "    gum::GibbsBNdistance< double >::GibbsBNdistance(gum::BNdistance< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GibbsBNdistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GibbsBNdistance" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_setBurnIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsBNdistance_setBurnIn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_setBurnIn" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsBNdistance_setBurnIn" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      (arg1)->setBurnIn(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_burnIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_burnIn" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      result = ((gum::GibbsBNdistance< double > const *)arg1)->burnIn();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_compute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_compute" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_GibbsBNdistance_Sl_double_Sg__compute(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_setVerbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsBNdistance_setVerbosity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_setVerbosity" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsBNdistance_setVerbosity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_GibbsBNdistance_Sl_double_Sg__setVerbosity(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_setEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsBNdistance_setEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_setEpsilon" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsBNdistance_setEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_GibbsBNdistance_Sl_double_Sg__setEpsilon(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_setMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsBNdistance_setMinEpsilonRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_setMinEpsilonRate" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsBNdistance_setMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_GibbsBNdistance_Sl_double_Sg__setMinEpsilonRate(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_setMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsBNdistance_setMaxIter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_setMaxIter" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsBNdistance_setMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_GibbsBNdistance_Sl_double_Sg__setMaxIter(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_setMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsBNdistance_setMaxTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_setMaxTime" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsBNdistance_setMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_GibbsBNdistance_Sl_double_Sg__setMaxTime(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_setPeriodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsBNdistance_setPeriodSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_setPeriodSize" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsBNdistance_setPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_GibbsBNdistance_Sl_double_Sg__setPeriodSize(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_verbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_verbosity" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      result = (bool)gum_GibbsBNdistance_Sl_double_Sg__verbosity((gum::GibbsBNdistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_epsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_epsilon" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      result = (double)gum_GibbsBNdistance_Sl_double_Sg__epsilon((gum::GibbsBNdistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_minEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_minEpsilonRate" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      result = (double)gum_GibbsBNdistance_Sl_double_Sg__minEpsilonRate((gum::GibbsBNdistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_maxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_maxIter" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      result = gum_GibbsBNdistance_Sl_double_Sg__maxIter((gum::GibbsBNdistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_maxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_maxTime" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      result = (double)gum_GibbsBNdistance_Sl_double_Sg__maxTime((gum::GibbsBNdistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_periodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_periodSize" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      result = gum_GibbsBNdistance_Sl_double_Sg__periodSize((gum::GibbsBNdistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_nbrIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_nbrIterations" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      result = gum_GibbsBNdistance_Sl_double_Sg__nbrIterations((gum::GibbsBNdistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_currentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_currentTime" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      result = (double)gum_GibbsBNdistance_Sl_double_Sg__currentTime((gum::GibbsBNdistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_messageApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_messageApproximationScheme" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      result = gum_GibbsBNdistance_Sl_double_Sg__messageApproximationScheme((gum::GibbsBNdistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_history" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_GibbsBNdistance_Sl_double_Sg__history((gum::GibbsBNdistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_asIApproximationSchemeConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_asIApproximationSchemeConfiguration" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration *) &gum_GibbsBNdistance_Sl_double_Sg__asIApproximationSchemeConfiguration((gum::GibbsBNdistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IApproximationSchemeConfiguration, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_nbrDrawnVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_nbrDrawnVar" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      result = gum_GibbsBNdistance_Sl_double_Sg__nbrDrawnVar((gum::GibbsBNdistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_setNbrDrawnVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsBNdistance_setNbrDrawnVar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_setNbrDrawnVar" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsBNdistance_setNbrDrawnVar" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_GibbsBNdistance_Sl_double_Sg__setNbrDrawnVar(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_isDrawnAtRandom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_isDrawnAtRandom" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  {
    try {
      result = (bool)gum_GibbsBNdistance_Sl_double_Sg__isDrawnAtRandom((gum::GibbsBNdistance< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GibbsBNdistance_setDrawnAtRandom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::GibbsBNdistance< double > *arg1 = (gum::GibbsBNdistance< double > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GibbsBNdistance_setDrawnAtRandom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GibbsBNdistance_setDrawnAtRandom" "', argument " "1"" of type '" "gum::GibbsBNdistance< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::GibbsBNdistance< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GibbsBNdistance_setDrawnAtRandom" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_GibbsBNdistance_Sl_double_Sg__setDrawnAtRandom(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GibbsBNdistance_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__GibbsBNdistanceT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GibbsBNdistance_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CredalNet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (gum::credal::CredalNet< double > *)new gum::credal::CredalNet< double >();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__credal__CredalNetT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CredalNet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  gum::credal::CredalNet< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CredalNet" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CredalNet" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CredalNet" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CredalNet" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::credal::CredalNet< double > *)new gum::credal::CredalNet< double >((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__credal__CredalNetT_double_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CredalNet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::credal::CredalNet< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CredalNet" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CredalNet" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::credal::CredalNet< double > *)new gum::credal::CredalNet< double >((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__credal__CredalNetT_double_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_new_CredalNet__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::credal::CredalNet< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CredalNet" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CredalNet" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CredalNet" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CredalNet" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::BayesNet< double > * >(argp2);
  {
    try {
      result = (gum::credal::CredalNet< double > *)new gum::credal::CredalNet< double >((gum::BayesNet< double > const &)*arg1,(gum::BayesNet< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__credal__CredalNetT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CredalNet__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::credal::CredalNet< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CredalNet" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CredalNet" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      result = (gum::credal::CredalNet< double > *)new gum::credal::CredalNet< double >((gum::BayesNet< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__credal__CredalNetT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CredalNet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CredalNet", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CredalNet__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CredalNet__SWIG_4(self, argc, argv);
    }
  }
  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_CredalNet__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CredalNet__SWIG_3(self, argc, argv);
      }
    }
  }
  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_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CredalNet__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CredalNet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::credal::CredalNet< double >::CredalNet()\n"
    "    gum::credal::CredalNet< double >::CredalNet(std::string const &,std::string const &)\n"
    "    gum::credal::CredalNet< double >::CredalNet(std::string const &)\n"
    "    gum::credal::CredalNet< double >::CredalNet(gum::BayesNet< double > const &,gum::BayesNet< double > const &)\n"
    "    gum::credal::CredalNet< double >::CredalNet(gum::BayesNet< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CredalNet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CredalNet" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_addVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  gum::Size *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  gum::Size temp3 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "CredalNet_addVariable", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_addVariable" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CredalNet_addVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredalNet_addVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CredalNet_addVariable" "', argument " "3"" of type '" "gum::Size""'");
  } 
  temp3 = static_cast< gum::Size >(val3);
  arg3 = &temp3;
  {
    try {
      result = (arg1)->addVariable((std::string const &)*arg2,(gum::Size const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_addArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  gum::NodeId *arg2 = 0 ;
  gum::NodeId *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeId temp2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::NodeId temp3 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CredalNet_addArc", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_addArc" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredalNet_addArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  temp2 = static_cast< gum::NodeId >(val2);
  arg2 = &temp2;
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CredalNet_addArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  temp3 = static_cast< gum::NodeId >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->addArc((gum::NodeId const &)*arg2,(gum::NodeId const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_setCPTs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  gum::NodeId *arg2 = 0 ;
  std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeId temp2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CredalNet_setCPTs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_setCPTs" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredalNet_setCPTs" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  temp2 = static_cast< gum::NodeId >(val2);
  arg2 = &temp2;
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CredalNet_setCPTs" "', argument " "3"" of type '" "std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredalNet_setCPTs" "', argument " "3"" of type '" "std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > * >(argp3);
  {
    try {
      (arg1)->setCPTs((gum::NodeId const &)*arg2,(std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_setCPT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  gum::NodeId *arg2 = 0 ;
  gum::Size *arg3 = 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeId temp2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_setCPT" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredalNet_setCPT" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  temp2 = static_cast< gum::NodeId >(val2);
  arg2 = &temp2;
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__size_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CredalNet_setCPT" "', argument " "3"" of type '" "gum::Size &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredalNet_setCPT" "', argument " "3"" of type '" "gum::Size &""'"); 
  }
  arg3 = reinterpret_cast< gum::Size * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &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 '" "CredalNet_setCPT" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredalNet_setCPT" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > * >(argp4);
  {
    try {
      (arg1)->setCPT((gum::NodeId const &)*arg2,*arg3,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_setCPT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  gum::NodeId *arg2 = 0 ;
  gum::Instantiation arg3 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeId temp2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_setCPT" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredalNet_setCPT" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  temp2 = static_cast< gum::NodeId >(val2);
  arg2 = &temp2;
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__Instantiation,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CredalNet_setCPT" "', argument " "3"" of type '" "gum::Instantiation""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredalNet_setCPT" "', argument " "3"" of type '" "gum::Instantiation""'");
    } else {
      gum::Instantiation * temp = reinterpret_cast< gum::Instantiation * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &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 '" "CredalNet_setCPT" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredalNet_setCPT" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > * >(argp4);
  {
    try {
      (arg1)->setCPT((gum::NodeId const &)*arg2,arg3,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_setCPT(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CredalNet_setCPT", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__size_t, SWIG_POINTER_NO_NULL);
        _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, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CredalNet_setCPT__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CredalNetT_double_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_gum__Instantiation, SWIG_POINTER_NO_NULL | 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, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CredalNet_setCPT__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CredalNet_setCPT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::credal::CredalNet< double >::setCPT(gum::NodeId const &,gum::Size &,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
    "    gum::credal::CredalNet< double >::setCPT(gum::NodeId const &,gum::Instantiation,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CredalNet_fillConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  gum::NodeId *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  std::vector< double,std::allocator< double > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeId temp2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CredalNet_fillConstraints", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_fillConstraints" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredalNet_fillConstraints" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  temp2 = static_cast< gum::NodeId >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CredalNet_fillConstraints" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredalNet_fillConstraints" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CredalNet_fillConstraints" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredalNet_fillConstraints" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      (arg1)->fillConstraints((gum::NodeId const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_fillConstraint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  gum::NodeId *arg2 = 0 ;
  gum::Idx *arg3 = 0 ;
  std::vector< double,std::allocator< double > > *arg4 = 0 ;
  std::vector< double,std::allocator< double > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeId temp2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  gum::Idx temp3 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_fillConstraint" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredalNet_fillConstraint" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  temp2 = static_cast< gum::NodeId >(val2);
  arg2 = &temp2;
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CredalNet_fillConstraint" "', argument " "3"" of type '" "gum::Idx""'");
  } 
  temp3 = static_cast< gum::Idx >(val3);
  arg3 = &temp3;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CredalNet_fillConstraint" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredalNet_fillConstraint" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CredalNet_fillConstraint" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredalNet_fillConstraint" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      (arg1)->fillConstraint((gum::NodeId const &)*arg2,(gum::Idx const &)*arg3,(std::vector< double,std::allocator< double > > const &)*arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_fillConstraint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  gum::NodeId *arg2 = 0 ;
  gum::Instantiation arg3 ;
  std::vector< double,std::allocator< double > > *arg4 = 0 ;
  std::vector< double,std::allocator< double > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeId temp2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_fillConstraint" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredalNet_fillConstraint" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  temp2 = static_cast< gum::NodeId >(val2);
  arg2 = &temp2;
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_gum__Instantiation,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CredalNet_fillConstraint" "', argument " "3"" of type '" "gum::Instantiation""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredalNet_fillConstraint" "', argument " "3"" of type '" "gum::Instantiation""'");
    } else {
      gum::Instantiation * temp = reinterpret_cast< gum::Instantiation * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CredalNet_fillConstraint" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredalNet_fillConstraint" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CredalNet_fillConstraint" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredalNet_fillConstraint" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      (arg1)->fillConstraint((gum::NodeId const &)*arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_fillConstraint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CredalNet_fillConstraint", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CredalNetT_double_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_gum__Instantiation, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_CredalNet_fillConstraint__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CredalNetT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_CredalNet_fillConstraint__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CredalNet_fillConstraint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::credal::CredalNet< double >::fillConstraint(gum::NodeId const &,gum::Idx const &,std::vector< double,std::allocator< double > > const &,std::vector< double,std::allocator< double > > const &)\n"
    "    gum::credal::CredalNet< double >::fillConstraint(gum::NodeId const &,gum::Instantiation,std::vector< double,std::allocator< double > > const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CredalNet_instantiation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  gum::NodeId *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeId temp2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Instantiation result;
  
  if (!SWIG_Python_UnpackTuple(args, "CredalNet_instantiation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_instantiation" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredalNet_instantiation" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  temp2 = static_cast< gum::NodeId >(val2);
  arg2 = &temp2;
  {
    try {
      result = (arg1)->instantiation((gum::NodeId const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::Instantiation(static_cast< const gum::Instantiation& >(result))), SWIGTYPE_p_gum__Instantiation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_domainSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  gum::NodeId *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeId temp2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Size result;
  
  if (!SWIG_Python_UnpackTuple(args, "CredalNet_domainSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_domainSize" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredalNet_domainSize" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  temp2 = static_cast< gum::NodeId >(val2);
  arg2 = &temp2;
  {
    try {
      result = (arg1)->domainSize((gum::NodeId const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_bnToCredal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  double arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_bnToCredal" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredalNet_bnToCredal" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CredalNet_bnToCredal" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CredalNet_bnToCredal" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      (arg1)->bnToCredal(arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_bnToCredal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  double arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_bnToCredal" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredalNet_bnToCredal" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CredalNet_bnToCredal" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      (arg1)->bnToCredal(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_bnToCredal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CredalNet_bnToCredal", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CredalNetT_double_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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CredalNet_bnToCredal__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CredalNetT_double_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_AsVal_bool(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_CredalNet_bnToCredal__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CredalNet_bnToCredal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::credal::CredalNet< double >::bnToCredal(double const,bool const,bool const)\n"
    "    gum::credal::CredalNet< double >::bnToCredal(double const,bool const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CredalNet_intervalToCredalWithFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_intervalToCredalWithFiles" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      (arg1)->intervalToCredalWithFiles();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_intervalToCredal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_intervalToCredal" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      (arg1)->intervalToCredal();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_lagrangeNormalization(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_lagrangeNormalization" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      (arg1)->lagrangeNormalization();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_idmLearning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  gum::Idx arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_idmLearning" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredalNet_idmLearning" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CredalNet_idmLearning" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      (arg1)->idmLearning(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_idmLearning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  gum::Idx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_idmLearning" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredalNet_idmLearning" "', argument " "2"" of type '" "gum::Idx""'");
  } 
  arg2 = static_cast< gum::Idx >(val2);
  {
    try {
      (arg1)->idmLearning(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_idmLearning__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_idmLearning" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      (arg1)->idmLearning();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_idmLearning(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CredalNet_idmLearning", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CredalNet_idmLearning__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CredalNetT_double_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_CredalNet_idmLearning__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CredalNetT_double_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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CredalNet_idmLearning__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CredalNet_idmLearning'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::credal::CredalNet< double >::idmLearning(gum::Idx const,bool const)\n"
    "    gum::credal::CredalNet< double >::idmLearning(gum::Idx const)\n"
    "    gum::credal::CredalNet< double >::idmLearning()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CredalNet_approximatedBinarization(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_approximatedBinarization" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      (arg1)->approximatedBinarization();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_saveBNsMinMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CredalNet_saveBNsMinMax", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_saveBNsMinMax" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CredalNet_saveBNsMinMax" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredalNet_saveBNsMinMax" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CredalNet_saveBNsMinMax" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredalNet_saveBNsMinMax" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      ((gum::credal::CredalNet< double > const *)arg1)->saveBNsMinMax((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_computeCPTMinMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_computeCPTMinMax" "', argument " "1"" of type '" "gum::credal::CredalNet< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      (arg1)->computeCPTMinMax();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_src_bn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::BayesNet< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_src_bn" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      result = (gum::BayesNet< double > *) &((gum::credal::CredalNet< double > const *)arg1)->src_bn();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_current_bn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::BayesNet< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_current_bn" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      result = (gum::BayesNet< double > *) &((gum::credal::CredalNet< double > const *)arg1)->current_bn();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__BayesNetT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_credalNet_currentCpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeProperty< std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_credalNet_currentCpt" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      result = (gum::NodeProperty< std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > > *) &((gum::credal::CredalNet< double > const *)arg1)->credalNet_currentCpt();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_credalNet_srcCpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::NodeProperty< std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_credalNet_srcCpt" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      result = (gum::NodeProperty< std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > > *) &((gum::credal::CredalNet< double > const *)arg1)->credalNet_srcCpt();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_currentNodeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  gum::NodeId *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeId temp2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::credal::CredalNet< double >::NodeType result;
  
  if (!SWIG_Python_UnpackTuple(args, "CredalNet_currentNodeType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_currentNodeType" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredalNet_currentNodeType" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  temp2 = static_cast< gum::NodeId >(val2);
  arg2 = &temp2;
  {
    try {
      result = (gum::credal::CredalNet< double >::NodeType)((gum::credal::CredalNet< double > const *)arg1)->currentNodeType((gum::NodeId const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_nodeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  gum::NodeId *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::NodeId temp2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::credal::CredalNet< double >::NodeType result;
  
  if (!SWIG_Python_UnpackTuple(args, "CredalNet_nodeType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_nodeType" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredalNet_nodeType" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  temp2 = static_cast< gum::NodeId >(val2);
  arg2 = &temp2;
  {
    try {
      result = (gum::credal::CredalNet< double >::NodeType)((gum::credal::CredalNet< double > const *)arg1)->nodeType((gum::NodeId const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_epsilonMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_epsilonMin" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      result = (double *) &((gum::credal::CredalNet< double > const *)arg1)->epsilonMin();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_epsilonMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_epsilonMax" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      result = (double *) &((gum::credal::CredalNet< double > const *)arg1)->epsilonMax();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_epsilonMean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_epsilonMean" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      result = (double *) &((gum::credal::CredalNet< double > const *)arg1)->epsilonMean();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_isSeparatelySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_isSeparatelySpecified" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      result = (bool)((gum::credal::CredalNet< double > const *)arg1)->isSeparatelySpecified();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_hasComputedCPTMinMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_hasComputedCPTMinMax" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      result = (bool)((gum::credal::CredalNet< double > const *)arg1)->hasComputedCPTMinMax();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet_get_CPT_min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_get_CPT_min" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *) &((gum::credal::CredalNet< double > const *)arg1)->get_CPT_min();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  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_CredalNet_get_CPT_max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet_get_CPT_max" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *) &((gum::credal::CredalNet< double > const *)arg1)->get_CPT_max();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  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_CredalNet___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet___repr__" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      result = gum_credal_CredalNet_Sl_double_Sg____repr__((gum::credal::CredalNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CredalNet___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = (gum::credal::CredalNet< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CredalNetT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredalNet___str__" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      result = gum_credal_CredalNet_Sl_double_Sg____str__((gum::credal::CredalNet< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CredalNet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__credal__CredalNetT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CredalNet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CNMonteCarloSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::credal::CNMonteCarloSampling< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__credal__CredalNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CNMonteCarloSampling" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CNMonteCarloSampling" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      result = (gum::credal::CNMonteCarloSampling< double > *)new gum::credal::CNMonteCarloSampling< double >((gum::credal::CredalNet< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CNMonteCarloSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CNMonteCarloSampling" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_makeInference" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    try {
      (arg1)->makeInference();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_insertEvidenceFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNMonteCarloSampling_insertEvidenceFile", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_insertEvidenceFile" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CNMonteCarloSampling_insertEvidenceFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CNMonteCarloSampling_insertEvidenceFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->insertEvidenceFile((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_setVerbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNMonteCarloSampling_setVerbosity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_setVerbosity" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNMonteCarloSampling_setVerbosity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_credal_CNMonteCarloSampling_Sl_double_Sg__setVerbosity(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_setEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNMonteCarloSampling_setEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_setEpsilon" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNMonteCarloSampling_setEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_credal_CNMonteCarloSampling_Sl_double_Sg__setEpsilon(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_setMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNMonteCarloSampling_setMinEpsilonRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_setMinEpsilonRate" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNMonteCarloSampling_setMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_credal_CNMonteCarloSampling_Sl_double_Sg__setMinEpsilonRate(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_setMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNMonteCarloSampling_setMaxIter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_setMaxIter" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNMonteCarloSampling_setMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_credal_CNMonteCarloSampling_Sl_double_Sg__setMaxIter(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_setMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNMonteCarloSampling_setMaxTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_setMaxTime" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNMonteCarloSampling_setMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_credal_CNMonteCarloSampling_Sl_double_Sg__setMaxTime(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_setPeriodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNMonteCarloSampling_setPeriodSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_setPeriodSize" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNMonteCarloSampling_setPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_credal_CNMonteCarloSampling_Sl_double_Sg__setPeriodSize(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_verbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_verbosity" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (bool)gum_credal_CNMonteCarloSampling_Sl_double_Sg__verbosity((gum::credal::CNMonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_epsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_epsilon" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_credal_CNMonteCarloSampling_Sl_double_Sg__epsilon((gum::credal::CNMonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_minEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_minEpsilonRate" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_credal_CNMonteCarloSampling_Sl_double_Sg__minEpsilonRate((gum::credal::CNMonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_maxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_maxIter" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    try {
      result = gum_credal_CNMonteCarloSampling_Sl_double_Sg__maxIter((gum::credal::CNMonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_maxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_maxTime" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_credal_CNMonteCarloSampling_Sl_double_Sg__maxTime((gum::credal::CNMonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_periodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_periodSize" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    try {
      result = gum_credal_CNMonteCarloSampling_Sl_double_Sg__periodSize((gum::credal::CNMonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_nbrIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_nbrIterations" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    try {
      result = gum_credal_CNMonteCarloSampling_Sl_double_Sg__nbrIterations((gum::credal::CNMonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_currentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_currentTime" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (double)gum_credal_CNMonteCarloSampling_Sl_double_Sg__currentTime((gum::credal::CNMonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_messageApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_messageApproximationScheme" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    try {
      result = gum_credal_CNMonteCarloSampling_Sl_double_Sg__messageApproximationScheme((gum::credal::CNMonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_history" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_credal_CNMonteCarloSampling_Sl_double_Sg__history((gum::credal::CNMonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_asIApproximationSchemeConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_asIApproximationSchemeConfiguration" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration *) &gum_credal_CNMonteCarloSampling_Sl_double_Sg__asIApproximationSchemeConfiguration((gum::credal::CNMonteCarloSampling< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IApproximationSchemeConfiguration, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_setRepetitiveInd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNMonteCarloSampling_setRepetitiveInd", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_setRepetitiveInd" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNMonteCarloSampling_setRepetitiveInd" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_credal_CNMonteCarloSampling_Sl_double_Sg__setRepetitiveInd(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_marginalMax__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_marginalMax" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNMonteCarloSampling_marginalMax" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_credal_CNMonteCarloSampling_Sl_double_Sg__marginalMax__SWIG_0((gum::credal::CNMonteCarloSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_marginalMin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_marginalMin" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNMonteCarloSampling_marginalMin" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_credal_CNMonteCarloSampling_Sl_double_Sg__marginalMin__SWIG_0((gum::credal::CNMonteCarloSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_marginalMax__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_marginalMax" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CNMonteCarloSampling_marginalMax" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_credal_CNMonteCarloSampling_Sl_double_Sg__marginalMax__SWIG_1((gum::credal::CNMonteCarloSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_marginalMax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CNMonteCarloSampling_marginalMax", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_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_CNMonteCarloSampling_marginalMax__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_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_CNMonteCarloSampling_marginalMax__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CNMonteCarloSampling_marginalMax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::credal::CNMonteCarloSampling< double >::marginalMax(gum::NodeId const) const\n"
    "    gum::credal::CNMonteCarloSampling< double >::marginalMax(std::string const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_marginalMin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_marginalMin" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CNMonteCarloSampling_marginalMin" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_credal_CNMonteCarloSampling_Sl_double_Sg__marginalMin__SWIG_1((gum::credal::CNMonteCarloSampling< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_marginalMin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CNMonteCarloSampling_marginalMin", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_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_CNMonteCarloSampling_marginalMin__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_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_CNMonteCarloSampling_marginalMin__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CNMonteCarloSampling_marginalMin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::credal::CNMonteCarloSampling< double >::marginalMin(gum::NodeId const) const\n"
    "    gum::credal::CNMonteCarloSampling< double >::marginalMin(std::string const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_insertModalsFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNMonteCarloSampling_insertModalsFile", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_insertModalsFile" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CNMonteCarloSampling_insertModalsFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CNMonteCarloSampling_insertModalsFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_credal_CNMonteCarloSampling_Sl_double_Sg__insertModalsFile(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_dynamicExpMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNMonteCarloSampling_dynamicExpMax", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_dynamicExpMax" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CNMonteCarloSampling_dynamicExpMax" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CNMonteCarloSampling_dynamicExpMax" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_credal_CNMonteCarloSampling_Sl_double_Sg__dynamicExpMax((gum::credal::CNMonteCarloSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNMonteCarloSampling_dynamicExpMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNMonteCarloSampling< double > *arg1 = (gum::credal::CNMonteCarloSampling< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNMonteCarloSampling_dynamicExpMin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNMonteCarloSampling_dynamicExpMin" "', argument " "1"" of type '" "gum::credal::CNMonteCarloSampling< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNMonteCarloSampling< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CNMonteCarloSampling_dynamicExpMin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CNMonteCarloSampling_dynamicExpMin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_credal_CNMonteCarloSampling_Sl_double_Sg__dynamicExpMin((gum::credal::CNMonteCarloSampling< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *CNMonteCarloSampling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CNMonteCarloSampling_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CNLoopyPropagation_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_makeInference" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      (arg1)->makeInference();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_inferenceType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  gum::credal::CNLoopyPropagation< double >::InferenceType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_inferenceType" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNLoopyPropagation_inferenceType" "', argument " "2"" of type '" "gum::credal::CNLoopyPropagation< double >::InferenceType""'");
  } 
  arg2 = static_cast< gum::credal::CNLoopyPropagation< double >::InferenceType >(val2);
  {
    try {
      (arg1)->inferenceType(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_inferenceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::credal::CNLoopyPropagation< double >::InferenceType result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_inferenceType" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      result = (gum::credal::CNLoopyPropagation< double >::InferenceType)(arg1)->inferenceType();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_inferenceType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_inferenceType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CNLoopyPropagation_inferenceType__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CNLoopyPropagation_inferenceType__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CNLoopyPropagation_inferenceType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::credal::CNLoopyPropagation< double >::inferenceType(gum::credal::CNLoopyPropagation< double >::InferenceType)\n"
    "    gum::credal::CNLoopyPropagation< double >::inferenceType()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_eraseAllEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_eraseAllEvidence" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      (arg1)->eraseAllEvidence();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_saveInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_saveInference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_saveInference" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CNLoopyPropagation_saveInference" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CNLoopyPropagation_saveInference" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->saveInference((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CNLoopyPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CredalNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::credal::CNLoopyPropagation< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__credal__CredalNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CNLoopyPropagation" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CNLoopyPropagation" "', argument " "1"" of type '" "gum::credal::CredalNet< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CredalNet< double > * >(argp1);
  {
    try {
      result = (gum::credal::CNLoopyPropagation< double > *)new gum::credal::CNLoopyPropagation< double >((gum::credal::CredalNet< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CNLoopyPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CNLoopyPropagation" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_insertEvidenceFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_insertEvidenceFile", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_insertEvidenceFile" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CNLoopyPropagation_insertEvidenceFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CNLoopyPropagation_insertEvidenceFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->insertEvidenceFile((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_setVerbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_setVerbosity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_setVerbosity" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNLoopyPropagation_setVerbosity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_credal_CNLoopyPropagation_Sl_double_Sg__setVerbosity(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_setEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_setEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_setEpsilon" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNLoopyPropagation_setEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_credal_CNLoopyPropagation_Sl_double_Sg__setEpsilon(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_setMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_setMinEpsilonRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_setMinEpsilonRate" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNLoopyPropagation_setMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_credal_CNLoopyPropagation_Sl_double_Sg__setMinEpsilonRate(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_setMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_setMaxIter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_setMaxIter" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNLoopyPropagation_setMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_credal_CNLoopyPropagation_Sl_double_Sg__setMaxIter(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_setMaxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_setMaxTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_setMaxTime" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNLoopyPropagation_setMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_credal_CNLoopyPropagation_Sl_double_Sg__setMaxTime(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_setPeriodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_setPeriodSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_setPeriodSize" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNLoopyPropagation_setPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_credal_CNLoopyPropagation_Sl_double_Sg__setPeriodSize(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_verbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_verbosity" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      result = (bool)gum_credal_CNLoopyPropagation_Sl_double_Sg__verbosity((gum::credal::CNLoopyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_epsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_epsilon" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      result = (double)gum_credal_CNLoopyPropagation_Sl_double_Sg__epsilon((gum::credal::CNLoopyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_minEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_minEpsilonRate" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      result = (double)gum_credal_CNLoopyPropagation_Sl_double_Sg__minEpsilonRate((gum::credal::CNLoopyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_maxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_maxIter" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      result = gum_credal_CNLoopyPropagation_Sl_double_Sg__maxIter((gum::credal::CNLoopyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_maxTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_maxTime" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      result = (double)gum_credal_CNLoopyPropagation_Sl_double_Sg__maxTime((gum::credal::CNLoopyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_periodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_periodSize" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      result = gum_credal_CNLoopyPropagation_Sl_double_Sg__periodSize((gum::credal::CNLoopyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_nbrIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_nbrIterations" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      result = gum_credal_CNLoopyPropagation_Sl_double_Sg__nbrIterations((gum::credal::CNLoopyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_currentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_currentTime" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      result = (double)gum_credal_CNLoopyPropagation_Sl_double_Sg__currentTime((gum::credal::CNLoopyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_messageApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_messageApproximationScheme" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      result = gum_credal_CNLoopyPropagation_Sl_double_Sg__messageApproximationScheme((gum::credal::CNLoopyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_history" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_credal_CNLoopyPropagation_Sl_double_Sg__history((gum::credal::CNLoopyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_asIApproximationSchemeConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_asIApproximationSchemeConfiguration" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration *) &gum_credal_CNLoopyPropagation_Sl_double_Sg__asIApproximationSchemeConfiguration((gum::credal::CNLoopyPropagation< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IApproximationSchemeConfiguration, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_setRepetitiveInd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_setRepetitiveInd", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_setRepetitiveInd" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNLoopyPropagation_setRepetitiveInd" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_credal_CNLoopyPropagation_Sl_double_Sg__setRepetitiveInd(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_marginalMax__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_marginalMax" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNLoopyPropagation_marginalMax" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_credal_CNLoopyPropagation_Sl_double_Sg__marginalMax__SWIG_0((gum::credal::CNLoopyPropagation< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_marginalMin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_marginalMin" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CNLoopyPropagation_marginalMin" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_credal_CNLoopyPropagation_Sl_double_Sg__marginalMin__SWIG_0((gum::credal::CNLoopyPropagation< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_marginalMax__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_marginalMax" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CNLoopyPropagation_marginalMax" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_credal_CNLoopyPropagation_Sl_double_Sg__marginalMax__SWIG_1((gum::credal::CNLoopyPropagation< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_marginalMax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_marginalMax", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_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_CNLoopyPropagation_marginalMax__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_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_CNLoopyPropagation_marginalMax__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CNLoopyPropagation_marginalMax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::credal::CNLoopyPropagation< double >::marginalMax(gum::NodeId const) const\n"
    "    gum::credal::CNLoopyPropagation< double >::marginalMax(std::string const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_marginalMin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_marginalMin" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CNLoopyPropagation_marginalMin" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_credal_CNLoopyPropagation_Sl_double_Sg__marginalMin__SWIG_1((gum::credal::CNLoopyPropagation< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_marginalMin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_marginalMin", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_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_CNLoopyPropagation_marginalMin__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_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_CNLoopyPropagation_marginalMin__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CNLoopyPropagation_marginalMin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::credal::CNLoopyPropagation< double >::marginalMin(gum::NodeId const) const\n"
    "    gum::credal::CNLoopyPropagation< double >::marginalMin(std::string const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_insertModalsFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_insertModalsFile", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_insertModalsFile" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CNLoopyPropagation_insertModalsFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CNLoopyPropagation_insertModalsFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_credal_CNLoopyPropagation_Sl_double_Sg__insertModalsFile(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_dynamicExpMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_dynamicExpMax", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_dynamicExpMax" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CNLoopyPropagation_dynamicExpMax" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CNLoopyPropagation_dynamicExpMax" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_credal_CNLoopyPropagation_Sl_double_Sg__dynamicExpMax((gum::credal::CNLoopyPropagation< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CNLoopyPropagation_dynamicExpMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::credal::CNLoopyPropagation< double > *arg1 = (gum::credal::CNLoopyPropagation< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "CNLoopyPropagation_dynamicExpMin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CNLoopyPropagation_dynamicExpMin" "', argument " "1"" of type '" "gum::credal::CNLoopyPropagation< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::credal::CNLoopyPropagation< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CNLoopyPropagation_dynamicExpMin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CNLoopyPropagation_dynamicExpMin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_credal_CNLoopyPropagation_Sl_double_Sg__dynamicExpMin((gum::credal::CNLoopyPropagation< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *CNLoopyPropagation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__credal__CNLoopyPropagationT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CNLoopyPropagation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InfluenceDiagram__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (gum::InfluenceDiagram< double > *)new gum::InfluenceDiagram< double >();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InfluenceDiagramT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InfluenceDiagram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InfluenceDiagram" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InfluenceDiagram__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::InfluenceDiagram< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__InfluenceDiagramT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InfluenceDiagram" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InfluenceDiagram" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = (gum::InfluenceDiagram< double > *)new gum::InfluenceDiagram< double >((gum::InfluenceDiagram< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InfluenceDiagramT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InfluenceDiagram(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InfluenceDiagram", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_InfluenceDiagram__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InfluenceDiagram__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InfluenceDiagram'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::InfluenceDiagram()\n"
    "    gum::InfluenceDiagram< double >::InfluenceDiagram(gum::InfluenceDiagram< double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_toDot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_toDot" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = ((gum::InfluenceDiagram< double > const *)arg1)->toDot();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_cpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_cpt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_cpt" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfluenceDiagram_cpt" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Potential< double > *) &((gum::InfluenceDiagram< double > const *)arg1)->cpt(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_utility(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Potential< double > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_utility", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_utility" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfluenceDiagram_utility" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::Potential< double > *) &((gum::InfluenceDiagram< double > const *)arg1)->utility(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_isUtilityNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_isUtilityNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_isUtilityNode" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfluenceDiagram_isUtilityNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)((gum::InfluenceDiagram< double > const *)arg1)->isUtilityNode(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_isDecisionNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_isDecisionNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_isDecisionNode" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfluenceDiagram_isDecisionNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)((gum::InfluenceDiagram< double > const *)arg1)->isDecisionNode(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_isChanceNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_isChanceNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_isChanceNode" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfluenceDiagram_isChanceNode" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (bool)((gum::InfluenceDiagram< double > const *)arg1)->isChanceNode(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_utilityNodeSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_utilityNodeSize" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = ((gum::InfluenceDiagram< double > const *)arg1)->utilityNodeSize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_chanceNodeSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_chanceNodeSize" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = ((gum::InfluenceDiagram< double > const *)arg1)->chanceNodeSize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_decisionNodeSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_decisionNodeSize" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = ((gum::InfluenceDiagram< double > const *)arg1)->decisionNodeSize();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_variable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_variable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_variable" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfluenceDiagram_variable" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::InfluenceDiagram< double > const *)arg1)->variable(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_nodeId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_nodeId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_nodeId" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_nodeId" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = ((gum::InfluenceDiagram< double > const *)arg1)->nodeId((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_idFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_idFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_idFromName" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((gum::InfluenceDiagram< double > const *)arg1)->idFromName((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_variableFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::DiscreteVariable *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_variableFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_variableFromName" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_variableFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::DiscreteVariable *) &((gum::InfluenceDiagram< double > const *)arg1)->variableFromName((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DiscreteVariable, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_add" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InfluenceDiagram_add" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (arg1)->add((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_add" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_add" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (arg1)->add((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_add", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InfluenceDiagram_add__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InfluenceDiagram_add__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::add(gum::DiscreteVariable const &,gum::NodeId)\n"
    "    gum::InfluenceDiagram< double >::add(gum::DiscreteVariable const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addChanceNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_addChanceNode" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_addChanceNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_addChanceNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InfluenceDiagram_addChanceNode" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (arg1)->addChanceNode((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addChanceNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_addChanceNode" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_addChanceNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_addChanceNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (arg1)->addChanceNode((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addUtilityNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (arg1)->addUtilityNode((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addUtilityNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (arg1)->addUtilityNode((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addDecisionNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_addDecisionNode" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_addDecisionNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_addDecisionNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InfluenceDiagram_addDecisionNode" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (arg1)->addDecisionNode((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addDecisionNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_addDecisionNode" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_addDecisionNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_addDecisionNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      result = (arg1)->addDecisionNode((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addDecisionNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_addDecisionNode", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InfluenceDiagram_addDecisionNode__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InfluenceDiagram_addDecisionNode__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_addDecisionNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::addDecisionNode(gum::DiscreteVariable const &,gum::NodeId)\n"
    "    gum::InfluenceDiagram< double >::addDecisionNode(gum::DiscreteVariable const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addChanceNode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::MultiDimImplementation< double > *arg3 = (gum::MultiDimImplementation< double > *) 0 ;
  gum::NodeId arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_addChanceNode" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_addChanceNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_addChanceNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InfluenceDiagram_addChanceNode" "', argument " "3"" of type '" "gum::MultiDimImplementation< double > *""'"); 
  }
  arg3 = reinterpret_cast< gum::MultiDimImplementation< double > * >(argp3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InfluenceDiagram_addChanceNode" "', argument " "4"" of type '" "gum::NodeId""'");
  } 
  arg4 = static_cast< gum::NodeId >(val4);
  {
    try {
      result = (arg1)->addChanceNode((gum::DiscreteVariable const &)*arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addChanceNode__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::MultiDimImplementation< double > *arg3 = (gum::MultiDimImplementation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_addChanceNode" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_addChanceNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_addChanceNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InfluenceDiagram_addChanceNode" "', argument " "3"" of type '" "gum::MultiDimImplementation< double > *""'"); 
  }
  arg3 = reinterpret_cast< gum::MultiDimImplementation< double > * >(argp3);
  {
    try {
      result = (arg1)->addChanceNode((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addChanceNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_addChanceNode", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InfluenceDiagram_addChanceNode__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InfluenceDiagram_addChanceNode__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InfluenceDiagram_addChanceNode__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_InfluenceDiagram_addChanceNode__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_addChanceNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::addChanceNode(gum::DiscreteVariable const &,gum::NodeId)\n"
    "    gum::InfluenceDiagram< double >::addChanceNode(gum::DiscreteVariable const &)\n"
    "    gum::InfluenceDiagram< double >::addChanceNode(gum::DiscreteVariable const &,gum::MultiDimImplementation< double > *,gum::NodeId)\n"
    "    gum::InfluenceDiagram< double >::addChanceNode(gum::DiscreteVariable const &,gum::MultiDimImplementation< double > *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addUtilityNode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::MultiDimImplementation< double > *arg3 = (gum::MultiDimImplementation< double > *) 0 ;
  gum::NodeId arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "3"" of type '" "gum::MultiDimImplementation< double > *""'"); 
  }
  arg3 = reinterpret_cast< gum::MultiDimImplementation< double > * >(argp3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "4"" of type '" "gum::NodeId""'");
  } 
  arg4 = static_cast< gum::NodeId >(val4);
  {
    try {
      result = (arg1)->addUtilityNode((gum::DiscreteVariable const &)*arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addUtilityNode__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  gum::MultiDimImplementation< double > *arg3 = (gum::MultiDimImplementation< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  gum::NodeId result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InfluenceDiagram_addUtilityNode" "', argument " "3"" of type '" "gum::MultiDimImplementation< double > *""'"); 
  }
  arg3 = reinterpret_cast< gum::MultiDimImplementation< double > * >(argp3);
  {
    try {
      result = (arg1)->addUtilityNode((gum::DiscreteVariable const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addUtilityNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_addUtilityNode", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InfluenceDiagram_addUtilityNode__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InfluenceDiagram_addUtilityNode__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InfluenceDiagram_addUtilityNode__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_gum__MultiDimImplementationT_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_InfluenceDiagram_addUtilityNode__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_addUtilityNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::addUtilityNode(gum::DiscreteVariable const &,gum::NodeId)\n"
    "    gum::InfluenceDiagram< double >::addUtilityNode(gum::DiscreteVariable const &)\n"
    "    gum::InfluenceDiagram< double >::addUtilityNode(gum::DiscreteVariable const &,gum::MultiDimImplementation< double > *,gum::NodeId)\n"
    "    gum::InfluenceDiagram< double >::addUtilityNode(gum::DiscreteVariable const &,gum::MultiDimImplementation< double > *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_erase" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfluenceDiagram_erase" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      (arg1)->erase(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::DiscreteVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_erase" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DiscreteVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_erase" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_erase" "', argument " "2"" of type '" "gum::DiscreteVariable const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DiscreteVariable * >(argp2);
  {
    try {
      (arg1)->erase((gum::DiscreteVariable const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_erase", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DiscreteVariable, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InfluenceDiagram_erase__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_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_InfluenceDiagram_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::erase(gum::NodeId)\n"
    "    gum::InfluenceDiagram< double >::erase(gum::DiscreteVariable const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_changeVariableName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::NodeId arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_changeVariableName", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_changeVariableName" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfluenceDiagram_changeVariableName" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InfluenceDiagram_changeVariableName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_changeVariableName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->changeVariableName(arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_addArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_addArc", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_addArc" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfluenceDiagram_addArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InfluenceDiagram_addArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->addArc(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_eraseArc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_eraseArc" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Arc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagram_eraseArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagram_eraseArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Arc * >(argp2);
  {
    try {
      (arg1)->eraseArc((gum::Arc const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_eraseArc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_eraseArc" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfluenceDiagram_eraseArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InfluenceDiagram_eraseArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      (arg1)->eraseArc(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_eraseArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_eraseArc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__Arc, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InfluenceDiagram_eraseArc__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InfluenceDiagram_eraseArc__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_eraseArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::eraseArc(gum::Arc const &)\n"
    "    gum::InfluenceDiagram< double >::eraseArc(gum::NodeId,gum::NodeId)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_decisionOrderExists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_decisionOrderExists" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = (bool)((gum::InfluenceDiagram< double > const *)arg1)->decisionOrderExists();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_getDecisionGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DAG *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_getDecisionGraph" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = (gum::DAG *)((gum::InfluenceDiagram< double > const *)arg1)->getDecisionGraph();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__DAG, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_getDecisionOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< gum::NodeId,std::allocator< gum::NodeId > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_getDecisionOrder" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = (std::vector< gum::NodeId,std::allocator< gum::NodeId > > *)((gum::InfluenceDiagram< double > const *)arg1)->getDecisionOrder();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_existsPathBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_existsPathBetween", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_existsPathBetween" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfluenceDiagram_existsPathBetween" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InfluenceDiagram_existsPathBetween" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      result = (bool)((gum::InfluenceDiagram< double > const *)arg1)->existsPathBetween(arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_names(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_names" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_InfluenceDiagram_Sl_double_Sg__names((gum::InfluenceDiagram< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_ids(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_ids" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_InfluenceDiagram_Sl_double_Sg__ids(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_arcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_arcs" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_InfluenceDiagram_Sl_double_Sg__arcs(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_parents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_parents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_parents" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfluenceDiagram_parents" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_InfluenceDiagram_Sl_double_Sg__parents((gum::InfluenceDiagram< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_children(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_children", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_children" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfluenceDiagram_children" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (PyObject *)gum_InfluenceDiagram_Sl_double_Sg__children((gum::InfluenceDiagram< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_loadBIFXML__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  std::string arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_loadBIFXML" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "InfluenceDiagram_loadBIFXML" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  arg3 = swig_obj[2];
  {
    try {
      result = (bool)gum_InfluenceDiagram_Sl_double_Sg__loadBIFXML__SWIG_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_loadBIFXML__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_loadBIFXML" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "InfluenceDiagram_loadBIFXML" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (bool)gum_InfluenceDiagram_Sl_double_Sg__loadBIFXML__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_loadBIFXML(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InfluenceDiagram_loadBIFXML", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_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_InfluenceDiagram_loadBIFXML__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__InfluenceDiagramT_double_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) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_InfluenceDiagram_loadBIFXML__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InfluenceDiagram_loadBIFXML'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::InfluenceDiagram< double >::loadBIFXML(std::string,PyObject *)\n"
    "    gum::InfluenceDiagram< double >::loadBIFXML(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram_saveBIFXML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagram_saveBIFXML", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram_saveBIFXML" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "InfluenceDiagram_saveBIFXML" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      gum_InfluenceDiagram_Sl_double_Sg__saveBIFXML(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram___repr__" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = gum_InfluenceDiagram_Sl_double_Sg____repr__((gum::InfluenceDiagram< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagram___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = (gum::InfluenceDiagram< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagram___str__" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = gum_InfluenceDiagram_Sl_double_Sg____str__((gum::InfluenceDiagram< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InfluenceDiagram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__InfluenceDiagramT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InfluenceDiagram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InfluenceDiagramInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagram< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::InfluenceDiagramInference< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__InfluenceDiagramT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InfluenceDiagramInference" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InfluenceDiagramInference" "', argument " "1"" of type '" "gum::InfluenceDiagram< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagram< double > * >(argp1);
  {
    try {
      result = (gum::InfluenceDiagramInference< double > *)new gum::InfluenceDiagramInference< double >((gum::InfluenceDiagram< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InfluenceDiagramInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagramInference< double > *arg1 = (gum::InfluenceDiagramInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InfluenceDiagramInference" "', argument " "1"" of type '" "gum::InfluenceDiagramInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagramInference< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagramInference_makeInference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagramInference< double > *arg1 = (gum::InfluenceDiagramInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagramInference_makeInference" "', argument " "1"" of type '" "gum::InfluenceDiagramInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagramInference< double > * >(argp1);
  {
    try {
      (arg1)->makeInference();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagramInference_getMEU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagramInference< double > *arg1 = (gum::InfluenceDiagramInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagramInference_getMEU" "', argument " "1"" of type '" "gum::InfluenceDiagramInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagramInference< double > * >(argp1);
  {
    try {
      result = (double)(arg1)->getMEU();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagramInference_getBestDecisionChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagramInference< double > *arg1 = (gum::InfluenceDiagramInference< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  gum::Idx result;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagramInference_getBestDecisionChoice", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagramInference_getBestDecisionChoice" "', argument " "1"" of type '" "gum::InfluenceDiagramInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagramInference< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfluenceDiagramInference_getBestDecisionChoice" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (arg1)->getBestDecisionChoice(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagramInference_displayResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagramInference< double > *arg1 = (gum::InfluenceDiagramInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagramInference_displayResult" "', argument " "1"" of type '" "gum::InfluenceDiagramInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagramInference< double > * >(argp1);
  {
    try {
      result = (arg1)->displayResult();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagramInference_insertEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagramInference< double > *arg1 = (gum::InfluenceDiagramInference< double > *) 0 ;
  gum::List< gum::Potential< double > const * > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagramInference_insertEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagramInference_insertEvidence" "', argument " "1"" of type '" "gum::InfluenceDiagramInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagramInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__ListT_gum__PotentialT_double_t_const_p_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagramInference_insertEvidence" "', argument " "2"" of type '" "gum::List< gum::Potential< double > const * > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagramInference_insertEvidence" "', argument " "2"" of type '" "gum::List< gum::Potential< double > const * > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::List< gum::Potential< double > const * > * >(argp2);
  {
    try {
      (arg1)->insertEvidence((gum::List< gum::Potential< double > const * > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagramInference_eraseEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagramInference< double > *arg1 = (gum::InfluenceDiagramInference< double > *) 0 ;
  gum::Potential< double > *arg2 = (gum::Potential< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagramInference_eraseEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagramInference_eraseEvidence" "', argument " "1"" of type '" "gum::InfluenceDiagramInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagramInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_gum__PotentialT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagramInference_eraseEvidence" "', argument " "2"" of type '" "gum::Potential< double > const *""'"); 
  }
  arg2 = reinterpret_cast< gum::Potential< double > * >(argp2);
  {
    try {
      (arg1)->eraseEvidence((gum::Potential< double > const *)arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagramInference_eraseAllEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagramInference< double > *arg1 = (gum::InfluenceDiagramInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagramInference_eraseAllEvidence" "', argument " "1"" of type '" "gum::InfluenceDiagramInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagramInference< double > * >(argp1);
  {
    try {
      (arg1)->eraseAllEvidence();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagramInference_displayStrongJunctionTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagramInference< double > *arg1 = (gum::InfluenceDiagramInference< double > *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagramInference_displayStrongJunctionTree", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagramInference_displayStrongJunctionTree" "', argument " "1"" of type '" "gum::InfluenceDiagramInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagramInference< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfluenceDiagramInference_displayStrongJunctionTree" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InfluenceDiagramInference_displayStrongJunctionTree" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      (arg1)->displayStrongJunctionTree(*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagramInference_influenceDiagram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagramInference< double > *arg1 = (gum::InfluenceDiagramInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::InfluenceDiagram< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagramInference_influenceDiagram" "', argument " "1"" of type '" "gum::InfluenceDiagramInference< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagramInference< double > * >(argp1);
  {
    try {
      result = (gum::InfluenceDiagram< double > *) &gum_InfluenceDiagramInference_Sl_double_Sg__influenceDiagram((gum::InfluenceDiagramInference< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__InfluenceDiagramT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagramInference_setEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagramInference< double > *arg1 = (gum::InfluenceDiagramInference< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagramInference_setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagramInference_setEvidence" "', argument " "1"" of type '" "gum::InfluenceDiagramInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagramInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_InfluenceDiagramInference_Sl_double_Sg__setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagramInference__setEvidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagramInference< double > *arg1 = (gum::InfluenceDiagramInference< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InfluenceDiagramInference__setEvidence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagramInference__setEvidence" "', argument " "1"" of type '" "gum::InfluenceDiagramInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagramInference< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_InfluenceDiagramInference_Sl_double_Sg___setEvidence(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InfluenceDiagramInference_junctionTreeToDot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::InfluenceDiagramInference< double > *arg1 = (gum::InfluenceDiagramInference< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfluenceDiagramInference_junctionTreeToDot" "', argument " "1"" of type '" "gum::InfluenceDiagramInference< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::InfluenceDiagramInference< double > * >(argp1);
  {
    try {
      result = gum_InfluenceDiagramInference_Sl_double_Sg__junctionTreeToDot(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InfluenceDiagramInference_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__InfluenceDiagramInferenceT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InfluenceDiagramInference_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BNLearner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BNLearner" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BNLearner" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BNLearner" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BNLearner" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *)new gum::learning::BNLearner< double >((std::string const &)*arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BNLearner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BNLearner" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BNLearner" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *)new gum::learning::BNLearner< double >((std::string const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_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_new_BNLearner__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::DatabaseTable< > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__learning__DatabaseTableT_std__allocator_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BNLearner" "', argument " "1"" of type '" "gum::learning::DatabaseTable< > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BNLearner" "', argument " "1"" of type '" "gum::learning::DatabaseTable< > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::DatabaseTable< > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *)new gum::learning::BNLearner< double >((gum::learning::DatabaseTable< > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BNLearner__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BNLearner" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BNLearner" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BNLearner" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BNLearner" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::BayesNet< double > * >(argp2);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BNLearner" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BNLearner" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (gum::learning::BNLearner< double > *)new gum::learning::BNLearner< double >((std::string const &)*arg1,(gum::BayesNet< double > const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BNLearner__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  gum::BayesNet< double > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BNLearner" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BNLearner" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BNLearner" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BNLearner" "', argument " "2"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::BayesNet< double > * >(argp2);
  {
    try {
      result = (gum::learning::BNLearner< double > *)new gum::learning::BNLearner< double >((std::string const &)*arg1,(gum::BayesNet< double > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_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_new_BNLearner__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__learning__BNLearnerT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BNLearner" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BNLearner" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *)new gum::learning::BNLearner< double >((gum::learning::BNLearner< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BNLearner__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::learning::BNLearner< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__learning__BNLearnerT_double_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BNLearner" "', argument " "1"" of type '" "gum::learning::BNLearner< double > &&""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BNLearner" "', argument " "1"" of type '" "gum::learning::BNLearner< double > &&""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNLearner< double > *)new gum::learning::BNLearner< double >((gum::learning::BNLearner< double > &&)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNLearnerT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BNLearner(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BNLearner", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__learning__DatabaseTableT_std__allocator_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BNLearner__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BNLearner__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BNLearner__SWIG_6(self, argc, argv);
    }
  }
  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_BNLearner__SWIG_1(self, argc, argv);
    }
  }
  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_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_BNLearner__SWIG_4(self, argc, argv);
      }
    }
  }
  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::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_BNLearner__SWIG_0(self, argc, argv);
      }
    }
  }
  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_gum__BayesNetT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_BNLearner__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BNLearner'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::BNLearner(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::learning::BNLearner< double >::BNLearner(std::string const &)\n"
    "    gum::learning::BNLearner< double >::BNLearner(gum::learning::DatabaseTable< > const &)\n"
    "    gum::learning::BNLearner< double >::BNLearner(std::string const &,gum::BayesNet< double > const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::learning::BNLearner< double >::BNLearner(std::string const &,gum::BayesNet< double > const &)\n"
    "    gum::learning::BNLearner< double >::BNLearner(gum::learning::BNLearner< double > const &)\n"
    "    gum::learning::BNLearner< double >::BNLearner(gum::learning::BNLearner< double > &&)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BNLearner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BNLearner" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_learnBN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::BayesNet< double > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_learnBN" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (arg1)->learnBN();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(static_cast< const gum::BayesNet< double >& >(result))), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_learnParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::DAG *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  gum::BayesNet< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_learnParameters" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DAG,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_learnParameters" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_learnParameters" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DAG * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNLearner_learnParameters" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (arg1)->learnParameters((gum::DAG const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(static_cast< const gum::BayesNet< double >& >(result))), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_learnParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::DAG *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  gum::BayesNet< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_learnParameters" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DAG,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_learnParameters" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_learnParameters" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DAG * >(argp2);
  {
    try {
      result = (arg1)->learnParameters((gum::DAG const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(static_cast< const gum::BayesNet< double >& >(result))), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_learnParameters__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  gum::BayesNet< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_learnParameters" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_learnParameters" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (arg1)->learnParameters(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(static_cast< const gum::BayesNet< double >& >(result))), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_learnParameters__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  gum::BayesNet< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_learnParameters" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (arg1)->learnParameters();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::BayesNet< double >(static_cast< const gum::BayesNet< double >& >(result))), SWIGTYPE_p_gum__BayesNetT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_learnParameters(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_learnParameters", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BNLearner_learnParameters__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BNLearner_learnParameters__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BNLearner_learnParameters__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__DAG, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BNLearner_learnParameters__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_learnParameters'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::learnParameters(gum::DAG const &,bool)\n"
    "    gum::learning::BNLearner< double >::learnParameters(gum::DAG const &)\n"
    "    gum::learning::BNLearner< double >::learnParameters(bool)\n"
    "    gum::learning::BNLearner< double >::learnParameters()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_chi2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  PyObject *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_chi2" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_chi2" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_chi2" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BNLearner_chi2" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_chi2" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BNLearner_chi2" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_chi2" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PyObject *)gum_learning_BNLearner_Sl_double_Sg__chi2__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_chi2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_chi2" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_chi2" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_chi2" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BNLearner_chi2" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_chi2" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (PyObject *)gum_learning_BNLearner_Sl_double_Sg__chi2__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_chi2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_chi2", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BNLearner_chi2__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::string,std::allocator< std::string > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_BNLearner_chi2__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_chi2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::chi2(std::string const &,std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    gum::learning::BNLearner< double >::chi2(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_setSliceOrder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_setSliceOrder" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__setSliceOrder__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useK2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useK2" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useK2__SWIG_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_latentVariables__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_latentVariables" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (PyObject *)gum_learning_BNLearner_Sl_double_Sg__latentVariables__SWIG_0(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setVerbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_setVerbosity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_setVerbosity" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_setVerbosity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__setVerbosity(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setEpsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_setEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_setEpsilon" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_setEpsilon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__setEpsilon(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setMinEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_setMinEpsilonRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_setMinEpsilonRate" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_setMinEpsilonRate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__setMinEpsilonRate(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_setMaxIter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_setMaxIter" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_setMaxIter" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__setMaxIter(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setMaxTime__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_setMaxTime" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_setMaxTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__setMaxTime__SWIG_0_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setMaxTime(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_setMaxTime", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BNLearner_setMaxTime__SWIG_0_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_setMaxTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    setMaxTime(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_setPeriodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_setPeriodSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_setPeriodSize" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_setPeriodSize" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__setPeriodSize(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_verbosity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_verbosity" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (bool)gum_learning_BNLearner_Sl_double_Sg__verbosity((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_epsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_epsilon" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__epsilon((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_minEpsilonRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_minEpsilonRate" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__minEpsilonRate((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_maxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_maxIter" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__maxIter((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_maxTime__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_maxTime" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__maxTime__SWIG_0_0((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_maxTime(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_maxTime", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BNLearner_maxTime__SWIG_0_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_maxTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    maxTime() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_periodSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_periodSize" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__periodSize((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_nbrIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_nbrIterations" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__nbrIterations((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_currentTime__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_currentTime" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__currentTime__SWIG_0_0((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_currentTime(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_currentTime", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BNLearner_currentTime__SWIG_0_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_currentTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    currentTime() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_messageApproximationScheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_messageApproximationScheme" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__messageApproximationScheme((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_history" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &gum_learning_BNLearner_Sl_double_Sg__history((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_asIApproximationSchemeConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::IApproximationSchemeConfiguration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_asIApproximationSchemeConfiguration" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (gum::IApproximationSchemeConfiguration *) &gum_learning_BNLearner_Sl_double_Sg__asIApproximationSchemeConfiguration((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__IApproximationSchemeConfiguration, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_learnDAG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::DAG result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_learnDAG" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__learnDAG(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::DAG(static_cast< const gum::DAG& >(result))), SWIGTYPE_p_gum__DAG, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_names(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_names" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (std::vector< std::string,std::allocator< std::string > > *) &gum_learning_BNLearner_Sl_double_Sg__names((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_idFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  gum::NodeId result;
  
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_idFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_idFromName" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_idFromName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__idFromName((gum::learning::BNLearner< double > const *)arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_nameFromId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::NodeId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_nameFromId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_nameFromId" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_nameFromId" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  {
    try {
      result = (std::string *) &gum_learning_BNLearner_Sl_double_Sg__nameFromId((gum::learning::BNLearner< double > const *)arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useScoreAIC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useScoreAIC" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useScoreAIC(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useScoreBD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useScoreBD" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useScoreBD(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useScoreBDeu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useScoreBDeu" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useScoreBDeu(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useScoreBIC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useScoreBIC" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useScoreBIC(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useScoreK2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useScoreK2" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useScoreK2(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useScoreLog2Likelihood(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useScoreLog2Likelihood" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useScoreLog2Likelihood(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setDatabaseWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_setDatabaseWeight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_setDatabaseWeight" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_setDatabaseWeight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__setDatabaseWeight(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useNoApriori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useNoApriori" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useNoApriori(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useAprioriSmoothing_SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useAprioriSmoothing" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_useAprioriSmoothing" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useAprioriSmoothing_SWIG_0_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useAprioriSmoothing_SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useAprioriSmoothing" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useAprioriSmoothing_SWIG_0_1(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useAprioriSmoothing(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_useAprioriSmoothing", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BNLearner_useAprioriSmoothing_SWIG_0_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BNLearner_useAprioriSmoothing_SWIG_0_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_useAprioriSmoothing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    useAprioriSmoothing(double)\n"
    "    useAprioriSmoothing()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_useAprioriDirichlet_SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useAprioriDirichlet" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_useAprioriDirichlet" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_useAprioriDirichlet" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNLearner_useAprioriDirichlet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useAprioriDirichlet_SWIG_0_0(arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useAprioriDirichlet_SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useAprioriDirichlet" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_useAprioriDirichlet" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_useAprioriDirichlet" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useAprioriDirichlet_SWIG_0_1(arg1,(std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useAprioriDirichlet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_useAprioriDirichlet", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_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_BNLearner_useAprioriDirichlet_SWIG_0_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_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_BNLearner_useAprioriDirichlet_SWIG_0_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_useAprioriDirichlet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    useAprioriDirichlet(std::string const &,double)\n"
    "    useAprioriDirichlet(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_useAprioriBDeu_SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useAprioriBDeu" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_useAprioriBDeu" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useAprioriBDeu_SWIG_0_0(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useAprioriBDeu_SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useAprioriBDeu" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useAprioriBDeu_SWIG_0_1(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useAprioriBDeu(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_useAprioriBDeu", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BNLearner_useAprioriBDeu_SWIG_0_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BNLearner_useAprioriBDeu_SWIG_0_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_useAprioriBDeu'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    useAprioriBDeu(double)\n"
    "    useAprioriBDeu()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_useGreedyHillClimbing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useGreedyHillClimbing" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useGreedyHillClimbing(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useLocalSearchWithTabuList_SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::Size arg2 ;
  gum::Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useLocalSearchWithTabuList" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_useLocalSearchWithTabuList" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNLearner_useLocalSearchWithTabuList" "', argument " "3"" of type '" "gum::Size""'");
  } 
  arg3 = static_cast< gum::Size >(val3);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useLocalSearchWithTabuList_SWIG_0_0(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useLocalSearchWithTabuList_SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useLocalSearchWithTabuList" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_useLocalSearchWithTabuList" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useLocalSearchWithTabuList_SWIG_0_1(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useLocalSearchWithTabuList_SWIG_0_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useLocalSearchWithTabuList" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useLocalSearchWithTabuList_SWIG_0_2(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useLocalSearchWithTabuList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_useLocalSearchWithTabuList", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BNLearner_useLocalSearchWithTabuList_SWIG_0_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_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_BNLearner_useLocalSearchWithTabuList_SWIG_0_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BNLearner_useLocalSearchWithTabuList_SWIG_0_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_useLocalSearchWithTabuList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    useLocalSearchWithTabuList(gum::Size,gum::Size)\n"
    "    useLocalSearchWithTabuList(gum::Size)\n"
    "    useLocalSearchWithTabuList()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_useK2__SWIG_1_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::Sequence< gum::NodeId > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useK2" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__SequenceT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_useK2" "', argument " "2"" of type '" "gum::Sequence< gum::NodeId > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_useK2" "', argument " "2"" of type '" "gum::Sequence< gum::NodeId > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Sequence< gum::NodeId > * >(argp2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useK2__SWIG_1_0(arg1,(gum::Sequence< std::size_t > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useK2__SWIG_1_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  std::vector< gum::NodeId,std::allocator< gum::NodeId > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useK2" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_useK2" "', argument " "2"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_useK2" "', argument " "2"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< gum::NodeId,std::allocator< gum::NodeId > > * >(argp2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useK2__SWIG_1_1(arg1,(std::vector< std::size_t,std::allocator< std::size_t > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useK2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_useK2", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__SequenceT_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BNLearner_useK2__SWIG_1_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BNLearner_useK2__SWIG_1_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        return _wrap_BNLearner_useK2__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_useK2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::useK2(PyObject *)\n"
    "    useK2(gum::Sequence< gum::NodeId > const &)\n"
    "    useK2(std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_setMaxIndegree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_setMaxIndegree", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_setMaxIndegree" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_setMaxIndegree" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__setMaxIndegree(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setSliceOrder__SWIG_1_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::NodeProperty< gum::NodeId > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_setSliceOrder" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__NodePropertyT_std__size_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_setSliceOrder" "', argument " "2"" of type '" "gum::NodeProperty< gum::NodeId > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_setSliceOrder" "', argument " "2"" of type '" "gum::NodeProperty< gum::NodeId > const &""'"); 
  }
  arg2 = reinterpret_cast< gum::NodeProperty< gum::NodeId > * >(argp2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__setSliceOrder__SWIG_1_0(arg1,(gum::NodeProperty< std::size_t > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setSliceOrder__SWIG_1_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_setSliceOrder" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_setSliceOrder" "', argument " "2"" of type '" "std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_setSliceOrder" "', argument " "2"" of type '" "std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > * >(argp2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__setSliceOrder__SWIG_1_1(arg1,(std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setSliceOrder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_setSliceOrder", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__NodePropertyT_std__size_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BNLearner_setSliceOrder__SWIG_1_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BNLearner_setSliceOrder__SWIG_1_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        return _wrap_BNLearner_setSliceOrder__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_setSliceOrder'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::setSliceOrder(PyObject *)\n"
    "    setSliceOrder(gum::NodeProperty< gum::NodeId > const &)\n"
    "    setSliceOrder(std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_addForbiddenArc_SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_addForbiddenArc" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Arc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_addForbiddenArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_addForbiddenArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Arc * >(argp2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__addForbiddenArc_SWIG_0_0(arg1,(gum::Arc const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addForbiddenArc_SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_addForbiddenArc" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_addForbiddenArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNLearner_addForbiddenArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__addForbiddenArc_SWIG_0_1(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addForbiddenArc_SWIG_0_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_addForbiddenArc" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_addForbiddenArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_addForbiddenArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BNLearner_addForbiddenArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_addForbiddenArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__addForbiddenArc_SWIG_0_2(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addForbiddenArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_addForbiddenArc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__Arc, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BNLearner_addForbiddenArc_SWIG_0_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BNLearner_addForbiddenArc_SWIG_0_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BNLearner_addForbiddenArc_SWIG_0_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_addForbiddenArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    addForbiddenArc(gum::Arc const &)\n"
    "    addForbiddenArc(gum::NodeId const,gum::NodeId const)\n"
    "    addForbiddenArc(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseForbiddenArc_SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_eraseForbiddenArc" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Arc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_eraseForbiddenArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_eraseForbiddenArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Arc * >(argp2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__eraseForbiddenArc_SWIG_0_0(arg1,(gum::Arc const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseForbiddenArc_SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_eraseForbiddenArc" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_eraseForbiddenArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNLearner_eraseForbiddenArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__eraseForbiddenArc_SWIG_0_1(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseForbiddenArc_SWIG_0_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_eraseForbiddenArc" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_eraseForbiddenArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_eraseForbiddenArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BNLearner_eraseForbiddenArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_eraseForbiddenArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__eraseForbiddenArc_SWIG_0_2(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseForbiddenArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_eraseForbiddenArc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__Arc, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BNLearner_eraseForbiddenArc_SWIG_0_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BNLearner_eraseForbiddenArc_SWIG_0_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BNLearner_eraseForbiddenArc_SWIG_0_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_eraseForbiddenArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    eraseForbiddenArc(gum::Arc const &)\n"
    "    eraseForbiddenArc(gum::NodeId const,gum::NodeId const)\n"
    "    eraseForbiddenArc(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_addMandatoryArc__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_addMandatoryArc" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Arc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_addMandatoryArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_addMandatoryArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Arc * >(argp2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__addMandatoryArc__SWIG_0_0(arg1,(gum::Arc const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addMandatoryArc__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_addMandatoryArc" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_addMandatoryArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNLearner_addMandatoryArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__addMandatoryArc__SWIG_0_1(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addMandatoryArc__SWIG_0_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_addMandatoryArc" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_addMandatoryArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_addMandatoryArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BNLearner_addMandatoryArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_addMandatoryArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__addMandatoryArc__SWIG_0_2(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_addMandatoryArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_addMandatoryArc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__Arc, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BNLearner_addMandatoryArc__SWIG_0_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BNLearner_addMandatoryArc__SWIG_0_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BNLearner_addMandatoryArc__SWIG_0_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_addMandatoryArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    addMandatoryArc(gum::Arc const &)\n"
    "    addMandatoryArc(gum::NodeId const,gum::NodeId const)\n"
    "    addMandatoryArc(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseMandatoryArc_SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::Arc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_eraseMandatoryArc" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__Arc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_eraseMandatoryArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_eraseMandatoryArc" "', argument " "2"" of type '" "gum::Arc const &""'"); 
  }
  arg2 = reinterpret_cast< gum::Arc * >(argp2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__eraseMandatoryArc_SWIG_0_0(arg1,(gum::Arc const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseMandatoryArc_SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::NodeId arg2 ;
  gum::NodeId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_eraseMandatoryArc" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_eraseMandatoryArc" "', argument " "2"" of type '" "gum::NodeId""'");
  } 
  arg2 = static_cast< gum::NodeId >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNLearner_eraseMandatoryArc" "', argument " "3"" of type '" "gum::NodeId""'");
  } 
  arg3 = static_cast< gum::NodeId >(val3);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__eraseMandatoryArc_SWIG_0_1(arg1,arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseMandatoryArc_SWIG_0_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_eraseMandatoryArc" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_eraseMandatoryArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_eraseMandatoryArc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BNLearner_eraseMandatoryArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_eraseMandatoryArc" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__eraseMandatoryArc_SWIG_0_2(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_eraseMandatoryArc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_eraseMandatoryArc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gum__Arc, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BNLearner_eraseMandatoryArc_SWIG_0_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BNLearner_eraseMandatoryArc_SWIG_0_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BNLearner_eraseMandatoryArc_SWIG_0_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_eraseMandatoryArc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    eraseMandatoryArc(gum::Arc const &)\n"
    "    eraseMandatoryArc(gum::NodeId const,gum::NodeId const)\n"
    "    eraseMandatoryArc(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_useEM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_useEM", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useEM" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNLearner_useEM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useEM(arg1,arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_hasMissingValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_hasMissingValues" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = (bool)gum_learning_BNLearner_Sl_double_Sg__hasMissingValues((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_logLikelihood_SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  std::vector< gum::NodeId,std::allocator< gum::NodeId > > *arg2 = 0 ;
  std::vector< gum::NodeId,std::allocator< gum::NodeId > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_logLikelihood" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_logLikelihood" "', argument " "2"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_logLikelihood" "', argument " "2"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< gum::NodeId,std::allocator< gum::NodeId > > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BNLearner_logLikelihood" "', argument " "3"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_logLikelihood" "', argument " "3"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< gum::NodeId,std::allocator< gum::NodeId > > * >(argp3);
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__logLikelihood_SWIG_0_0(arg1,(std::vector< std::size_t,std::allocator< std::size_t > > const &)*arg2,(std::vector< std::size_t,std::allocator< std::size_t > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_logLikelihood_SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  std::vector< gum::NodeId,std::allocator< gum::NodeId > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_logLikelihood" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_logLikelihood" "', argument " "2"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_logLikelihood" "', argument " "2"" of type '" "std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< gum::NodeId,std::allocator< gum::NodeId > > * >(argp2);
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__logLikelihood_SWIG_0_1(arg1,(std::vector< std::size_t,std::allocator< std::size_t > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_logLikelihood_SWIG_0_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_logLikelihood" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_logLikelihood" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_logLikelihood" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BNLearner_logLikelihood" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_logLikelihood" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__logLikelihood_SWIG_0_2(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_logLikelihood_SWIG_0_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_logLikelihood" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_logLikelihood" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_logLikelihood" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (double)gum_learning_BNLearner_Sl_double_Sg__logLikelihood_SWIG_0_3(arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_logLikelihood(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_logLikelihood", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BNLearner_logLikelihood_SWIG_0_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BNLearner_logLikelihood_SWIG_0_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BNLearner_logLikelihood_SWIG_0_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BNLearner_logLikelihood_SWIG_0_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_logLikelihood'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    logLikelihood(std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &,std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)\n"
    "    logLikelihood(std::vector< gum::NodeId,std::allocator< gum::NodeId > > const &)\n"
    "    logLikelihood(std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    logLikelihood(std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_nbRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_nbRows" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__nbRows((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_nbCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_nbCols" "', argument " "1"" of type '" "gum::learning::BNLearner< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__nbCols((gum::learning::BNLearner< double > const *)arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_setInitialDAG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  gum::DAG *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BNLearner_setInitialDAG", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_setInitialDAG" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_gum__DAG,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNLearner_setInitialDAG" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNLearner_setInitialDAG" "', argument " "2"" of type '" "gum::DAG const &""'"); 
  }
  arg2 = reinterpret_cast< gum::DAG * >(argp2);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__setInitialDAG(arg1,(gum::DAG const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_use3off2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_use3off2" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__use3off2(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useMIIC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useMIIC" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useMIIC(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useNML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useNML" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useNML(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useMDL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useMDL" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useMDL(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_useNoCorr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_useNoCorr" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      gum_learning_BNLearner_Sl_double_Sg__useNoCorr(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_latentVariables__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::vector< gum::Arc,std::allocator< gum::Arc > > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_latentVariables" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__latentVariables__SWIG_1(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< gum::Arc,std::allocator< gum::Arc > >(static_cast< const std::vector< gum::Arc,std::allocator< gum::Arc > >& >(result))), SWIGTYPE_p_std__vectorT_gum__Arc_std__allocatorT_gum__Arc_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNLearner_latentVariables(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNLearner_latentVariables", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BNLearner_latentVariables__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BNLearner_latentVariables__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNLearner_latentVariables'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNLearner< double >::latentVariables()\n"
    "    gum::learning::BNLearner< double >::latentVariables()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNLearner_learnMixedStructure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNLearner< double > *arg1 = (gum::learning::BNLearner< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::MixedGraph result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNLearnerT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNLearner_learnMixedStructure" "', argument " "1"" of type '" "gum::learning::BNLearner< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNLearner< double > * >(argp1);
  {
    try {
      result = gum_learning_BNLearner_Sl_double_Sg__learnMixedStructure(arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::MixedGraph(static_cast< const gum::MixedGraph& >(result))), SWIGTYPE_p_gum__MixedGraph, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BNLearner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__learning__BNLearnerT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BNLearner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BNDatabaseGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::BayesNet< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  gum::learning::BNDatabaseGenerator< double > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_gum__BayesNetT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BNDatabaseGenerator" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BNDatabaseGenerator" "', argument " "1"" of type '" "gum::BayesNet< double > const &""'"); 
  }
  arg1 = reinterpret_cast< gum::BayesNet< double > * >(argp1);
  {
    try {
      result = (gum::learning::BNDatabaseGenerator< double > *)new gum::learning::BNDatabaseGenerator< double >((gum::BayesNet< double > const &)*arg1);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BNDatabaseGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BNDatabaseGenerator" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_drawSamples(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  gum::Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "BNDatabaseGenerator_drawSamples", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_drawSamples" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNDatabaseGenerator_drawSamples" "', argument " "2"" of type '" "gum::Size""'");
  } 
  arg2 = static_cast< gum::Size >(val2);
  {
    try {
      result = (double)(arg1)->drawSamples(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_toCSV__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  std::string arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNDatabaseGenerator_toCSV" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      ((gum::learning::BNDatabaseGenerator< double > const *)arg1)->toCSV((std::string const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_toCSV__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNDatabaseGenerator_toCSV" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      ((gum::learning::BNDatabaseGenerator< double > const *)arg1)->toCSV((std::string const &)*arg2,arg3,arg4,arg5);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_toCSV__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNDatabaseGenerator_toCSV" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      ((gum::learning::BNDatabaseGenerator< double > const *)arg1)->toCSV((std::string const &)*arg2,arg3,arg4);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_toCSV__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNDatabaseGenerator_toCSV" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      ((gum::learning::BNDatabaseGenerator< double > const *)arg1)->toCSV((std::string const &)*arg2,arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_toCSV__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNDatabaseGenerator_toCSV" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNDatabaseGenerator_toCSV" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      ((gum::learning::BNDatabaseGenerator< double > const *)arg1)->toCSV((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_toCSV(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNDatabaseGenerator_toCSV", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_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_BNDatabaseGenerator_toCSV__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_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_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BNDatabaseGenerator_toCSV__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_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_bool(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_BNDatabaseGenerator_toCSV__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_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_bool(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_BNDatabaseGenerator_toCSV__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_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_bool(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_BNDatabaseGenerator_toCSV__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNDatabaseGenerator_toCSV'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNDatabaseGenerator< double >::toCSV(std::string const &,bool,bool,std::string,bool) const\n"
    "    gum::learning::BNDatabaseGenerator< double >::toCSV(std::string const &,bool,bool,std::string) const\n"
    "    gum::learning::BNDatabaseGenerator< double >::toCSV(std::string const &,bool,bool) const\n"
    "    gum::learning::BNDatabaseGenerator< double >::toCSV(std::string const &,bool) const\n"
    "    gum::learning::BNDatabaseGenerator< double >::toCSV(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_toDatabaseTable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< gum::learning::DatabaseTable< > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_toDatabaseTable" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BNDatabaseGenerator_toDatabaseTable" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = ((gum::learning::BNDatabaseGenerator< double > const *)arg1)->toDatabaseTable(arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::learning::DatabaseTable< >(static_cast< const gum::learning::DatabaseTable< >& >(result))), SWIGTYPE_p_gum__learning__DatabaseTableT_std__allocator_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_toDatabaseTable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< gum::learning::DatabaseTable< > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_toDatabaseTable" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    try {
      result = ((gum::learning::BNDatabaseGenerator< double > const *)arg1)->toDatabaseTable();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new gum::learning::DatabaseTable< >(static_cast< const gum::learning::DatabaseTable< >& >(result))), SWIGTYPE_p_gum__learning__DatabaseTableT_std__allocator_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_toDatabaseTable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNDatabaseGenerator_toDatabaseTable", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BNDatabaseGenerator_toDatabaseTable__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BNDatabaseGenerator_toDatabaseTable__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNDatabaseGenerator_toDatabaseTable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNDatabaseGenerator< double >::toDatabaseTable(bool) const\n"
    "    gum::learning::BNDatabaseGenerator< double >::toDatabaseTable() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_database(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< std::vector< std::size_t,std::allocator< std::size_t > >,std::allocator< std::vector< std::size_t,std::allocator< std::size_t > > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_database" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    try {
      result = ((gum::learning::BNDatabaseGenerator< double > const *)arg1)->database();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< gum::Idx,std::allocator< gum::Idx > >,std::allocator< std::vector< gum::Idx,std::allocator< gum::Idx > > > >(static_cast< const std::vector< std::vector< gum::Idx,std::allocator< gum::Idx > >,std::allocator< std::vector< gum::Idx,std::allocator< gum::Idx > > > >& >(result))), SWIGTYPE_p_std__vectorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_std__allocatorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_setVarOrder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  std::vector< gum::Idx,std::allocator< gum::Idx > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_setVarOrder" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNDatabaseGenerator_setVarOrder" "', argument " "2"" of type '" "std::vector< gum::Idx,std::allocator< gum::Idx > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNDatabaseGenerator_setVarOrder" "', argument " "2"" of type '" "std::vector< gum::Idx,std::allocator< gum::Idx > > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< gum::Idx,std::allocator< gum::Idx > > * >(argp2);
  {
    try {
      (arg1)->setVarOrder((std::vector< gum::Idx,std::allocator< gum::Idx > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_setVarOrder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_setVarOrder" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNDatabaseGenerator_setVarOrder" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNDatabaseGenerator_setVarOrder" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->setVarOrder((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_setVarOrder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNDatabaseGenerator_setVarOrder", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BNDatabaseGenerator_setVarOrder__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BNDatabaseGenerator_setVarOrder__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNDatabaseGenerator_setVarOrder'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNDatabaseGenerator< double >::setVarOrder(std::vector< gum::Idx,std::allocator< gum::Idx > > const &)\n"
    "    gum::learning::BNDatabaseGenerator< double >::setVarOrder(std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_setVarOrderFromCSV__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_setVarOrderFromCSV" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNDatabaseGenerator_setVarOrderFromCSV" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNDatabaseGenerator_setVarOrderFromCSV" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BNDatabaseGenerator_setVarOrderFromCSV" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNDatabaseGenerator_setVarOrderFromCSV" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->setVarOrderFromCSV((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_setVarOrderFromCSV__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_setVarOrderFromCSV" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BNDatabaseGenerator_setVarOrderFromCSV" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BNDatabaseGenerator_setVarOrderFromCSV" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->setVarOrderFromCSV((std::string const &)*arg2);
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_setVarOrderFromCSV(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BNDatabaseGenerator_setVarOrderFromCSV", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_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_BNDatabaseGenerator_setVarOrderFromCSV__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BNDatabaseGenerator_setVarOrderFromCSV__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BNDatabaseGenerator_setVarOrderFromCSV'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gum::learning::BNDatabaseGenerator< double >::setVarOrderFromCSV(std::string const &,std::string const &)\n"
    "    gum::learning::BNDatabaseGenerator< double >::setVarOrderFromCSV(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_setTopologicalVarOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_setTopologicalVarOrder" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    try {
      (arg1)->setTopologicalVarOrder();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_setAntiTopologicalVarOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_setAntiTopologicalVarOrder" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    try {
      (arg1)->setAntiTopologicalVarOrder();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_setRandomVarOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_setRandomVarOrder" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    try {
      (arg1)->setRandomVarOrder();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_varOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< std::size_t,std::allocator< std::size_t > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_varOrder" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    try {
      result = ((gum::learning::BNDatabaseGenerator< double > const *)arg1)->varOrder();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< gum::Idx,std::allocator< gum::Idx > >(static_cast< const std::vector< gum::Idx,std::allocator< gum::Idx > >& >(result))), SWIGTYPE_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_varOrderNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_varOrderNames" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    try {
      result = ((gum::learning::BNDatabaseGenerator< double > const *)arg1)->varOrderNames();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BNDatabaseGenerator_log2likelihood(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  gum::learning::BNDatabaseGenerator< double > *arg1 = (gum::learning::BNDatabaseGenerator< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BNDatabaseGenerator_log2likelihood" "', argument " "1"" of type '" "gum::learning::BNDatabaseGenerator< double > const *""'"); 
  }
  arg1 = reinterpret_cast< gum::learning::BNDatabaseGenerator< double > * >(argp1);
  {
    try {
      result = (double)((gum::learning::BNDatabaseGenerator< double > const *)arg1)->log2likelihood();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BNDatabaseGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_gum__learning__BNDatabaseGeneratorT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BNDatabaseGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_statsObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "statsObj", 0, 0, 0)) SWIG_fail;
  {
    try {
      gum::statsObj();
    } catch (...) {
      SetPythonizeAgrumException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


static PyMethodDef SwigMethods[] = {
	 { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, "delete_SwigPyIterator(SwigPyIterator self)"},
	 { "SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_O, "SwigPyIterator_value(SwigPyIterator self) -> PyObject *"},
	 { "SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, "SwigPyIterator_incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"},
	 { "SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, "SwigPyIterator_decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"},
	 { "SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, "SwigPyIterator_distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"},
	 { "SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, "SwigPyIterator_equal(SwigPyIterator self, SwigPyIterator x) -> bool"},
	 { "SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_O, "SwigPyIterator_copy(SwigPyIterator self) -> SwigPyIterator"},
	 { "SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_O, "SwigPyIterator_next(SwigPyIterator self) -> PyObject *"},
	 { "SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_O, "SwigPyIterator___next__(SwigPyIterator self) -> PyObject *"},
	 { "SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_O, "SwigPyIterator_previous(SwigPyIterator self) -> PyObject *"},
	 { "SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, "SwigPyIterator_advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"},
	 { "SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, "SwigPyIterator___eq__(SwigPyIterator self, SwigPyIterator x) -> bool"},
	 { "SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, "SwigPyIterator___ne__(SwigPyIterator self, SwigPyIterator x) -> bool"},
	 { "SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, "SwigPyIterator___iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"},
	 { "SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, "SwigPyIterator___isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"},
	 { "SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, "SwigPyIterator___add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"},
	 { "SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, "\n"
		"SwigPyIterator___sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator\n"
		"SwigPyIterator___sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t\n"
		""},
	 { "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL},
	 { "JunctionTreeGenerator_junctionTree", _wrap_JunctionTreeGenerator_junctionTree, METH_VARARGS, "\n"
		"JunctionTreeGenerator_junctionTree(JunctionTreeGenerator self, UndiGraph g, PyObject * partial_order=None) -> CliqueGraph\n"
		"JunctionTreeGenerator_junctionTree(JunctionTreeGenerator self, DAG dag, PyObject * partial_order=None) -> CliqueGraph\n"
		"JunctionTreeGenerator_junctionTree(JunctionTreeGenerator self, BayesNet bn, PyObject * partial_order=None) -> CliqueGraph\n"
		"\n"
		"Computes the junction tree for its parameters. If the first parameter is a graph, the heurisitcs assume that all the node have the same domain size (2). If given, the heuristic takes into account the partial order for its elimination order.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"g : pyAgrum.UndiGraph\n"
		"	a undirected graph\n"
		"\n"
		"dag : pyAgrum.DAG\n"
		"	a dag\n"
		"\n"
		"bn : pyAgrum.BayesNet\n"
		"	a BayesianNetwork\n"
		"\n"
		"partial_order: List[List[int]]\n"
		"	a partial order among the nodeIDs\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.CliqueGraph\n"
		"	the current junction tree. \n"
		"\n"
		""},
	 { "JunctionTreeGenerator_eliminationOrder", _wrap_JunctionTreeGenerator_eliminationOrder, METH_VARARGS, "\n"
		"JunctionTreeGenerator_eliminationOrder(JunctionTreeGenerator self, UndiGraph g, PyObject * partial_order=None) -> PyObject\n"
		"JunctionTreeGenerator_eliminationOrder(JunctionTreeGenerator self, DAG dag, PyObject * partial_order=None) -> PyObject\n"
		"JunctionTreeGenerator_eliminationOrder(JunctionTreeGenerator self, BayesNet bn, PyObject * partial_order=None) -> PyObject\n"
		"\n"
		"Computes the elimination for its parameters. If the first parameter is a graph, the heurisitcs assume that all the node have the same domain size (2). If given, the heuristic takes into account the partial order for its elimination order.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"g : pyAgrum.UndiGraph\n"
		"	a undirected graph\n"
		"\n"
		"dag : pyAgrum.DAG\n"
		"	a dag\n"
		"\n"
		"bn : pyAgrum.BayesNet\n"
		"	a BayesianNetwork\n"
		"\n"
		"partial_order: List[List[int]]\n"
		"	a partial order among the nodeIDs\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.CliqueGraph\n"
		"	the current elimination order.\n"
		"\n"
		""},
	 { "JunctionTreeGenerator_binaryJoinTree", _wrap_JunctionTreeGenerator_binaryJoinTree, METH_VARARGS, "\n"
		"JunctionTreeGenerator_binaryJoinTree(JunctionTreeGenerator self, UndiGraph g, PyObject * partial_order=None) -> CliqueGraph\n"
		"JunctionTreeGenerator_binaryJoinTree(JunctionTreeGenerator self, DAG dag, PyObject * partial_order=None) -> CliqueGraph\n"
		"JunctionTreeGenerator_binaryJoinTree(JunctionTreeGenerator self, BayesNet bn, PyObject * partial_order=None) -> CliqueGraph\n"
		"\n"
		"Computes the binary joint tree for its parameters. If the first parameter is a graph, the heurisitcs assume that all the node have the same domain size (2). If given, the heuristic takes into account the partial order for its elimination order.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"g : pyAgrum.UndiGraph\n"
		"	a undirected graph\n"
		"\n"
		"dag : pyAgrum.DAG\n"
		"	a dag\n"
		"\n"
		"bn : pyAgrum.BayesNet\n"
		"	a BayesianNetwork\n"
		"\n"
		"partial_order: List[List[int]]\n"
		"	a partial order among the nodeIDs\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.CliqueGraph\n"
		"	the current binary joint tree \n"
		"\n"
		""},
	 { "new_JunctionTreeGenerator", _wrap_new_JunctionTreeGenerator, METH_NOARGS, "\n"
		"new_JunctionTreeGenerator() -> JunctionTreeGenerator\n"
		"\n"
		"JunctionTreeGenerator is use to generate junction tree or binary junction tree from bayesian networks.\n"
		"\n"
		"Available constructors:\n"
		"	``JunctionTreeGenerator() -> JunctionTreeGenerator``\n"
		"\n"
		""},
	 { "delete_JunctionTreeGenerator", _wrap_delete_JunctionTreeGenerator, METH_O, "delete_JunctionTreeGenerator(JunctionTreeGenerator self)"},
	 { "JunctionTreeGenerator_swigregister", JunctionTreeGenerator_swigregister, METH_VARARGS, NULL},
	 { "JunctionTreeGenerator_swiginit", JunctionTreeGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_PythonBNListener", _wrap_new_PythonBNListener, METH_VARARGS, "new_PythonBNListener(BayesNet bn, VariableNodeMap vnm) -> PythonBNListener"},
	 { "delete_PythonBNListener", _wrap_delete_PythonBNListener, METH_O, "delete_PythonBNListener(PythonBNListener self)"},
	 { "PythonBNListener_whenNodeAdded", _wrap_PythonBNListener_whenNodeAdded, METH_VARARGS, "PythonBNListener_whenNodeAdded(PythonBNListener self, void const * source, gum::NodeId id)"},
	 { "PythonBNListener_whenNodeDeleted", _wrap_PythonBNListener_whenNodeDeleted, METH_VARARGS, "PythonBNListener_whenNodeDeleted(PythonBNListener self, void const * arg2, gum::NodeId id)"},
	 { "PythonBNListener_whenArcAdded", _wrap_PythonBNListener_whenArcAdded, METH_VARARGS, "PythonBNListener_whenArcAdded(PythonBNListener self, void const * arg2, gum::NodeId src, gum::NodeId dst)"},
	 { "PythonBNListener_whenArcDeleted", _wrap_PythonBNListener_whenArcDeleted, METH_VARARGS, "PythonBNListener_whenArcDeleted(PythonBNListener self, void const * arg2, gum::NodeId src, gum::NodeId dst)"},
	 { "PythonBNListener_setWhenArcAdded", _wrap_PythonBNListener_setWhenArcAdded, METH_VARARGS, "\n"
		"PythonBNListener_setWhenArcAdded(PythonBNListener self, PyObject * pyfunc)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "PythonBNListener_setWhenArcDeleted", _wrap_PythonBNListener_setWhenArcDeleted, METH_VARARGS, "\n"
		"PythonBNListener_setWhenArcDeleted(PythonBNListener self, PyObject * pyfunc)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "PythonBNListener_setWhenNodeAdded", _wrap_PythonBNListener_setWhenNodeAdded, METH_VARARGS, "\n"
		"PythonBNListener_setWhenNodeAdded(PythonBNListener self, PyObject * pyfunc)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "PythonBNListener_setWhenNodeDeleted", _wrap_PythonBNListener_setWhenNodeDeleted, METH_VARARGS, "\n"
		"PythonBNListener_setWhenNodeDeleted(PythonBNListener self, PyObject * pyfunc)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "PythonBNListener_swigregister", PythonBNListener_swigregister, METH_VARARGS, NULL},
	 { "PythonBNListener_swiginit", PythonBNListener_swiginit, METH_VARARGS, NULL},
	 { "PythonLoadListener_whenLoading", _wrap_PythonLoadListener_whenLoading, METH_VARARGS, "PythonLoadListener_whenLoading(PythonLoadListener self, void const * buffer, int percent)"},
	 { "PythonLoadListener_setPythonListener", _wrap_PythonLoadListener_setPythonListener, METH_VARARGS, "\n"
		"PythonLoadListener_setPythonListener(PythonLoadListener self, PyObject * l) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "new_PythonLoadListener", _wrap_new_PythonLoadListener, METH_NOARGS, "new_PythonLoadListener() -> PythonLoadListener"},
	 { "delete_PythonLoadListener", _wrap_delete_PythonLoadListener, METH_O, "delete_PythonLoadListener(PythonLoadListener self)"},
	 { "PythonLoadListener_swigregister", PythonLoadListener_swigregister, METH_VARARGS, NULL},
	 { "PythonLoadListener_swiginit", PythonLoadListener_swiginit, METH_VARARGS, NULL},
	 { "__fillLoadListeners", _wrap___fillLoadListeners, METH_VARARGS, "__fillLoadListeners(std::vector< PythonLoadListener,std::allocator< PythonLoadListener > > & py_listener, PyObject * l) -> int"},
	 { "new_PythonApproximationListener", _wrap_new_PythonApproximationListener, METH_O, "\n"
		"new_PythonApproximationListener(IApproximationSchemeConfiguration algo) -> PythonApproximationListener\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"algo : IApproximationSchemeConfiguration\n"
		"	an approxmation scheme\n"
		"\n"
		""},
	 { "delete_PythonApproximationListener", _wrap_delete_PythonApproximationListener, METH_O, "delete_PythonApproximationListener(PythonApproximationListener self)"},
	 { "PythonApproximationListener_whenProgress", _wrap_PythonApproximationListener_whenProgress, METH_VARARGS, "PythonApproximationListener_whenProgress(PythonApproximationListener self, void const * src, gum::Size const step, double const error, double const duration)"},
	 { "PythonApproximationListener_whenStop", _wrap_PythonApproximationListener_whenStop, METH_VARARGS, "PythonApproximationListener_whenStop(PythonApproximationListener self, void const * src, std::string const message)"},
	 { "PythonApproximationListener_setWhenProgress", _wrap_PythonApproximationListener_setWhenProgress, METH_VARARGS, "\n"
		"PythonApproximationListener_setWhenProgress(PythonApproximationListener self, PyObject * pyfunc)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pyfunc\n"
		"	the function to execute\n"
		"\n"
		""},
	 { "PythonApproximationListener_setWhenStop", _wrap_PythonApproximationListener_setWhenStop, METH_VARARGS, "\n"
		"PythonApproximationListener_setWhenStop(PythonApproximationListener self, PyObject * pyfunc)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pyfunc\n"
		"	the function to execute\n"
		"\n"
		""},
	 { "PythonApproximationListener_swigregister", PythonApproximationListener_swigregister, METH_VARARGS, NULL},
	 { "PythonApproximationListener_swiginit", PythonApproximationListener_swiginit, METH_VARARGS, NULL},
	 { "new_PythonDatabaseGeneratorListener", _wrap_new_PythonDatabaseGeneratorListener, METH_O, "new_PythonDatabaseGeneratorListener(BNDatabaseGenerator notif) -> PythonDatabaseGeneratorListener"},
	 { "delete_PythonDatabaseGeneratorListener", _wrap_delete_PythonDatabaseGeneratorListener, METH_O, "delete_PythonDatabaseGeneratorListener(PythonDatabaseGeneratorListener self)"},
	 { "PythonDatabaseGeneratorListener_whenProgress", _wrap_PythonDatabaseGeneratorListener_whenProgress, METH_VARARGS, "PythonDatabaseGeneratorListener_whenProgress(PythonDatabaseGeneratorListener self, void const * src, gum::Size const step, double const duration)"},
	 { "PythonDatabaseGeneratorListener_whenStop", _wrap_PythonDatabaseGeneratorListener_whenStop, METH_VARARGS, "PythonDatabaseGeneratorListener_whenStop(PythonDatabaseGeneratorListener self, void const * src, std::string const & message)"},
	 { "PythonDatabaseGeneratorListener_setWhenProgress", _wrap_PythonDatabaseGeneratorListener_setWhenProgress, METH_VARARGS, "PythonDatabaseGeneratorListener_setWhenProgress(PythonDatabaseGeneratorListener self, PyObject * pyfunc)"},
	 { "PythonDatabaseGeneratorListener_setWhenStop", _wrap_PythonDatabaseGeneratorListener_setWhenStop, METH_VARARGS, "PythonDatabaseGeneratorListener_setWhenStop(PythonDatabaseGeneratorListener self, PyObject * pyfunc)"},
	 { "PythonDatabaseGeneratorListener_swigregister", PythonDatabaseGeneratorListener_swigregister, METH_VARARGS, NULL},
	 { "PythonDatabaseGeneratorListener_swiginit", PythonDatabaseGeneratorListener_swiginit, METH_VARARGS, NULL},
	 { "BNGenerator_generate", _wrap_BNGenerator_generate, METH_VARARGS, "\n"
		"BNGenerator_generate(BNGenerator self, gum::Size n_nodes=10, gum::Size n_arcs=15, gum::Size n_modmax=4) -> BayesNet\n"
		"\n"
		"Generate a new Bayesian network \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n_nodes : int\n"
		"	the number of nodes (default=10)\n"
		"n_arcs : int\n"
		"	the number of arcs (default=15)\n"
		"n_nodmax : int\n"
		"	the max number of modalities for a node (default=4)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.BayesNet\n"
		"	the generated Bayesian network\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If n_modmax < 2\n"
		"gum.OperationNotAllowed\n"
		"	If n_arcs is incompatible with n_nodes (not enough arcs)\n"
		"\n"
		""},
	 { "new_BNGenerator", _wrap_new_BNGenerator, METH_NOARGS, "\n"
		"new_BNGenerator() -> BNGenerator\n"
		"\n"
		"BNGenerator is used to easily generate Bayesian networks.\n"
		"\n"
		"Available constructors:\n"
		"\n"
		"    ``BNGenerator() -> BNGenerator``\n"
		"\n"
		""},
	 { "delete_BNGenerator", _wrap_delete_BNGenerator, METH_O, "delete_BNGenerator(BNGenerator self)"},
	 { "BNGenerator_swigregister", BNGenerator_swigregister, METH_VARARGS, NULL},
	 { "BNGenerator_swiginit", BNGenerator_swiginit, METH_VARARGS, NULL},
	 { "IDGenerator_generate", _wrap_IDGenerator_generate, METH_VARARGS, "\n"
		"IDGenerator_generate(IDGenerator self, gum::Size nbrNodes=10, double arcDensity=0.2, double chanceNodeDensity=0.8, double utilityNodeDensity=0.1, int max_modality=2) -> InfluenceDiagram\n"
		"\n"
		"Generate a new influence diagram given the parameters.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nbrNodes : int\n"
		"	the number of node\n"
		"arcDensity : double\n"
		"	the density of arc (1 for a complete graph)\n"
		"chanceNodeDensity : double\n"
		"	the density of chance node\n"
		"utilityNodeDensity : double\n"
		"	the density of utility node\n"
		"max_modality : int\n"
		"	the maximum value for modalities\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.InfluenceDiagram\n"
		"	the generated influence diagram\n"
		"\n"
		""},
	 { "new_IDGenerator", _wrap_new_IDGenerator, METH_NOARGS, "\n"
		"new_IDGenerator() -> IDGenerator\n"
		"\n"
		"IDGenerator is used to easily generate influence diagrams.\n"
		"\n"
		"Available constructors:\n"
		"\n"
		"    ``IDGenerator() -> IDGenerator``\n"
		"\n"
		""},
	 { "delete_IDGenerator", _wrap_delete_IDGenerator, METH_O, "delete_IDGenerator(IDGenerator self)"},
	 { "IDGenerator_swigregister", IDGenerator_swigregister, METH_VARARGS, NULL},
	 { "IDGenerator_swiginit", IDGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_PRMexplorer", _wrap_new_PRMexplorer, METH_NOARGS, "\n"
		"new_PRMexplorer() -> PRMexplorer\n"
		"\n"
		"PRMexplorer helps navigate through probabilistic relational models.\n"
		"\n"
		"Available constructors:\n"
		"	``PRMexplorer() -> PRMexplorer``\n"
		"\n"
		""},
	 { "delete_PRMexplorer", _wrap_delete_PRMexplorer, METH_O, "delete_PRMexplorer(PRMexplorer self)"},
	 { "PRMexplorer_load", _wrap_PRMexplorer_load, METH_VARARGS, "\n"
		"PRMexplorer_load(PRMexplorer self, std::string filename, std::string classpath=\"\", bool verbose=False)\n"
		"\n"
		"Load a PRM into the explorer.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"filename : str\n"
		"	the name of the o3prm file\n"
		"classpath : str\n"
		"	the classpath of the PRM\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.FatalError\n"
		"	If file not found\n"
		"\n"
		""},
	 { "PRMexplorer_isType", _wrap_PRMexplorer_isType, METH_VARARGS, "\n"
		"PRMexplorer_isType(PRMexplorer self, std::string name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	an element name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the parameter correspond to a type in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_isClass", _wrap_PRMexplorer_isClass, METH_VARARGS, "\n"
		"PRMexplorer_isClass(PRMexplorer self, std::string name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	an element name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the parameter correspond to a class in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_isInterface", _wrap_PRMexplorer_isInterface, METH_VARARGS, "\n"
		"PRMexplorer_isInterface(PRMexplorer self, std::string name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	an element name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the parameter correspond to an interface in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_classes", _wrap_PRMexplorer_classes, METH_O, "\n"
		"PRMexplorer_classes(PRMexplorer self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of classes\n"
		"\n"
		""},
	 { "PRMexplorer_classAttributes", _wrap_PRMexplorer_classAttributes, METH_VARARGS, "\n"
		"PRMexplorer_classAttributes(PRMexplorer self, std::string class_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"class_name : str\n"
		"	a class name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of attributes\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_isAttribute", _wrap_PRMexplorer_isAttribute, METH_VARARGS, "\n"
		"PRMexplorer_isAttribute(PRMexplorer self, std::string class_name, std::string att_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"class_name : str\n"
		"	a class name\n"
		"att_name : str\n"
		"	the name of the attribute to be tested\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if att_name is an attribute of class_name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the class is not in the PRM\n"
		"gum.IndexError\n"
		"	If att_name is not an element of class_name\n"
		"\n"
		""},
	 { "PRMexplorer_classReferences", _wrap_PRMexplorer_classReferences, METH_VARARGS, "\n"
		"PRMexplorer_classReferences(PRMexplorer self, std::string class_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"class_name : str\n"
		"	a class name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of references\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_classParameters", _wrap_PRMexplorer_classParameters, METH_VARARGS, "\n"
		"PRMexplorer_classParameters(PRMexplorer self, std::string class_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"class_name : str\n"
		"	a class name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of parameters\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_classImplements", _wrap_PRMexplorer_classImplements, METH_VARARGS, "\n"
		"PRMexplorer_classImplements(PRMexplorer self, std::string class_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"class_name : str\n"
		"	a class name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of interfaces implemented by the class\n"
		"\n"
		""},
	 { "PRMexplorer_aggType_set", _wrap_PRMexplorer_aggType_set, METH_VARARGS, "\n"
		"PRMexplorer_aggType_set(PRMexplorer self, std::string [9] aggType)\n"
		"\n"
		"min/max/count/exists/forall/or/and/amplitude/median\n"
		"\n"
		""},
	 { "PRMexplorer_aggType_get", _wrap_PRMexplorer_aggType_get, METH_O, "\n"
		"PRMexplorer_aggType_get(PRMexplorer self) -> std::string [9]\n"
		"\n"
		"min/max/count/exists/forall/or/and/amplitude/median\n"
		"\n"
		""},
	 { "PRMexplorer_classAggregates", _wrap_PRMexplorer_classAggregates, METH_VARARGS, "\n"
		"PRMexplorer_classAggregates(PRMexplorer self, std::string class_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"class_name : str\n"
		"	a class name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of aggregates in the class\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_classSlotChains", _wrap_PRMexplorer_classSlotChains, METH_VARARGS, "\n"
		"PRMexplorer_classSlotChains(PRMexplorer self, std::string class_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"class_name : str\n"
		"	a class name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of class slot chains\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError \n"
		"	if the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_classDag", _wrap_PRMexplorer_classDag, METH_VARARGS, "\n"
		"PRMexplorer_classDag(PRMexplorer self, std::string class_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"class_name : str\n"
		"	a class name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	a description of the DAG\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getalltheSystems", _wrap_PRMexplorer_getalltheSystems, METH_O, "\n"
		"PRMexplorer_getalltheSystems(PRMexplorer self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of all the systems and their components\n"
		"\n"
		""},
	 { "PRMexplorer_getSuperClass", _wrap_PRMexplorer_getSuperClass, METH_VARARGS, "\n"
		"PRMexplorer_getSuperClass(PRMexplorer self, std::string class_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"class_name : str\n"
		"	a class name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the class extended by class_name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getDirectSubClass", _wrap_PRMexplorer_getDirectSubClass, METH_VARARGS, "\n"
		"PRMexplorer_getDirectSubClass(PRMexplorer self, std::string class_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"class_name : str\n"
		"	a class name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of direct subclasses\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the class is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_cpf", _wrap_PRMexplorer_cpf, METH_VARARGS, "\n"
		"PRMexplorer_cpf(PRMexplorer self, std::string class_name, std::string attribute) -> Potential\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"class_name : str\n"
		"	a class name\n"
		"\n"
		"attribute : str\n"
		"	an attribute\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"	the potential of the attribute\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If the class element doesn't have any gum::Potential (like a gum::PRMReferenceSlot). \n"
		"gum.IndexError\n"
		"	If the class is not in the PRM\n"
		"gum.IndexError\n"
		"	If the attribute in parameters does not exist \n"
		"\n"
		""},
	 { "PRMexplorer_types", _wrap_PRMexplorer_types, METH_O, "\n"
		"PRMexplorer_types(PRMexplorer self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of the custom types in the PRM \n"
		"\n"
		""},
	 { "PRMexplorer_getSuperType", _wrap_PRMexplorer_getSuperType, METH_VARARGS, "\n"
		"PRMexplorer_getSuperType(PRMexplorer self, std::string type_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type_name : str\n"
		"	a type name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the type extended by type_name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the type is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getDirectSubTypes", _wrap_PRMexplorer_getDirectSubTypes, METH_VARARGS, "\n"
		"PRMexplorer_getDirectSubTypes(PRMexplorer self, std::string type_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type_name : str\n"
		"	a type name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of direct subtypes\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the type is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getLabels", _wrap_PRMexplorer_getLabels, METH_VARARGS, "\n"
		"PRMexplorer_getLabels(PRMexplorer self, std::string type_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type_name : str\n"
		"	a type name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of type labels\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the type is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getLabelMap", _wrap_PRMexplorer_getLabelMap, METH_VARARGS, "\n"
		"PRMexplorer_getLabelMap(PRMexplorer self, std::string type_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type_name : str\n"
		"	a type name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict\n"
		"	a dict containing pairs of label and their values \n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the type is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_interfaces", _wrap_PRMexplorer_interfaces, METH_O, "\n"
		"PRMexplorer_interfaces(PRMexplorer self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of interfaces in the PRM \n"
		"\n"
		""},
	 { "PRMexplorer_interAttributes", _wrap_PRMexplorer_interAttributes, METH_VARARGS, "\n"
		"PRMexplorer_interAttributes(PRMexplorer self, std::string interface_name, bool allAttributes=False) -> PyObject\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"interface_name : str\n"
		"	an interface\n"
		"\n"
		"allAttributes : bool\n"
		"	True if supertypes of a custom type should be indicated\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of (<type>,<attribute_name>) for the given interface\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the type is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_interReferences", _wrap_PRMexplorer_interReferences, METH_VARARGS, "\n"
		"PRMexplorer_interReferences(PRMexplorer self, std::string interface_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"interface_name : str\n"
		"	an interface\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of (<reference_type>,<reference_name>,<True if the reference is an array>) for the given interface\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the type is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getSuperInterface", _wrap_PRMexplorer_getSuperInterface, METH_VARARGS, "\n"
		"PRMexplorer_getSuperInterface(PRMexplorer self, std::string interface_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"interface_name : str\n"
		"	an interface name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the interace extended by interface_name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the interface is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getDirectSubInterfaces", _wrap_PRMexplorer_getDirectSubInterfaces, METH_VARARGS, "\n"
		"PRMexplorer_getDirectSubInterfaces(PRMexplorer self, std::string interface_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"interface_name : str\n"
		"	an interface name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of direct subinterfaces\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the interface is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_getImplementations", _wrap_PRMexplorer_getImplementations, METH_VARARGS, "\n"
		"PRMexplorer_getImplementations(PRMexplorer self, std::string interface_name) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"interface_name : str\n"
		"	an interface name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the list of classes implementing the interface \n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the interface is not in the PRM\n"
		"\n"
		""},
	 { "PRMexplorer_swigregister", PRMexplorer_swigregister, METH_VARARGS, NULL},
	 { "PRMexplorer_swiginit", PRMexplorer_swiginit, METH_VARARGS, NULL},
	 { "Vector_iterator", _wrap_Vector_iterator, METH_O, "Vector_iterator(Vector self) -> SwigPyIterator"},
	 { "Vector___nonzero__", _wrap_Vector___nonzero__, METH_O, "Vector___nonzero__(Vector self) -> bool"},
	 { "Vector___bool__", _wrap_Vector___bool__, METH_O, "Vector___bool__(Vector self) -> bool"},
	 { "Vector___len__", _wrap_Vector___len__, METH_O, "Vector___len__(Vector self) -> std::vector< double >::size_type"},
	 { "Vector___getslice__", _wrap_Vector___getslice__, METH_VARARGS, "Vector___getslice__(Vector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> Vector"},
	 { "Vector___setslice__", _wrap_Vector___setslice__, METH_VARARGS, "\n"
		"Vector___setslice__(Vector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)\n"
		"Vector___setslice__(Vector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, Vector v)\n"
		""},
	 { "Vector___delslice__", _wrap_Vector___delslice__, METH_VARARGS, "Vector___delslice__(Vector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"},
	 { "Vector___delitem__", _wrap_Vector___delitem__, METH_VARARGS, "\n"
		"Vector___delitem__(Vector self, std::vector< double >::difference_type i)\n"
		"Vector___delitem__(Vector self, PySliceObject * slice)\n"
		""},
	 { "Vector___getitem__", _wrap_Vector___getitem__, METH_VARARGS, "\n"
		"Vector___getitem__(Vector self, PySliceObject * slice) -> Vector\n"
		"Vector___getitem__(Vector self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &\n"
		""},
	 { "Vector___setitem__", _wrap_Vector___setitem__, METH_VARARGS, "\n"
		"Vector___setitem__(Vector self, PySliceObject * slice, Vector v)\n"
		"Vector___setitem__(Vector self, PySliceObject * slice)\n"
		"Vector___setitem__(Vector self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)\n"
		""},
	 { "Vector_pop", _wrap_Vector_pop, METH_O, "Vector_pop(Vector self) -> std::vector< double >::value_type"},
	 { "Vector_append", _wrap_Vector_append, METH_VARARGS, "Vector_append(Vector self, std::vector< double >::value_type const & x)"},
	 { "Vector_empty", _wrap_Vector_empty, METH_O, "Vector_empty(Vector self) -> bool"},
	 { "Vector_size", _wrap_Vector_size, METH_O, "Vector_size(Vector self) -> std::vector< double >::size_type"},
	 { "Vector_swap", _wrap_Vector_swap, METH_VARARGS, "Vector_swap(Vector self, Vector v)"},
	 { "Vector_begin", _wrap_Vector_begin, METH_O, "Vector_begin(Vector self) -> std::vector< double >::iterator"},
	 { "Vector_end", _wrap_Vector_end, METH_O, "Vector_end(Vector self) -> std::vector< double >::iterator"},
	 { "Vector_rbegin", _wrap_Vector_rbegin, METH_O, "Vector_rbegin(Vector self) -> std::vector< double >::reverse_iterator"},
	 { "Vector_rend", _wrap_Vector_rend, METH_O, "Vector_rend(Vector self) -> std::vector< double >::reverse_iterator"},
	 { "Vector_clear", _wrap_Vector_clear, METH_O, "Vector_clear(Vector self)"},
	 { "Vector_get_allocator", _wrap_Vector_get_allocator, METH_O, "Vector_get_allocator(Vector self) -> std::vector< double >::allocator_type"},
	 { "Vector_pop_back", _wrap_Vector_pop_back, METH_O, "Vector_pop_back(Vector self)"},
	 { "Vector_erase", _wrap_Vector_erase, METH_VARARGS, "\n"
		"Vector_erase(Vector self, std::vector< double >::iterator pos) -> std::vector< double >::iterator\n"
		"Vector_erase(Vector self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator\n"
		""},
	 { "new_Vector", _wrap_new_Vector, METH_VARARGS, "\n"
		"Vector()\n"
		"Vector(Vector arg1)\n"
		"Vector(std::vector< double >::size_type size)\n"
		"new_Vector(std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> Vector\n"
		""},
	 { "Vector_push_back", _wrap_Vector_push_back, METH_VARARGS, "Vector_push_back(Vector self, std::vector< double >::value_type const & x)"},
	 { "Vector_front", _wrap_Vector_front, METH_O, "Vector_front(Vector self) -> std::vector< double >::value_type const &"},
	 { "Vector_back", _wrap_Vector_back, METH_O, "Vector_back(Vector self) -> std::vector< double >::value_type const &"},
	 { "Vector_assign", _wrap_Vector_assign, METH_VARARGS, "Vector_assign(Vector self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"},
	 { "Vector_resize", _wrap_Vector_resize, METH_VARARGS, "\n"
		"Vector_resize(Vector self, std::vector< double >::size_type new_size)\n"
		"Vector_resize(Vector self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)\n"
		""},
	 { "Vector_insert", _wrap_Vector_insert, METH_VARARGS, "\n"
		"Vector_insert(Vector self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator\n"
		"Vector_insert(Vector self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)\n"
		""},
	 { "Vector_reserve", _wrap_Vector_reserve, METH_VARARGS, "Vector_reserve(Vector self, std::vector< double >::size_type n)"},
	 { "Vector_capacity", _wrap_Vector_capacity, METH_O, "Vector_capacity(Vector self) -> std::vector< double >::size_type"},
	 { "delete_Vector", _wrap_delete_Vector, METH_O, "delete_Vector(Vector self)"},
	 { "Vector_swigregister", Vector_swigregister, METH_VARARGS, NULL},
	 { "Vector_swiginit", Vector_swiginit, METH_VARARGS, NULL},
	 { "Vector_int_iterator", _wrap_Vector_int_iterator, METH_O, "Vector_int_iterator(Vector_int self) -> SwigPyIterator"},
	 { "Vector_int___nonzero__", _wrap_Vector_int___nonzero__, METH_O, "Vector_int___nonzero__(Vector_int self) -> bool"},
	 { "Vector_int___bool__", _wrap_Vector_int___bool__, METH_O, "Vector_int___bool__(Vector_int self) -> bool"},
	 { "Vector_int___len__", _wrap_Vector_int___len__, METH_O, "Vector_int___len__(Vector_int self) -> std::vector< unsigned int >::size_type"},
	 { "Vector_int___getslice__", _wrap_Vector_int___getslice__, METH_VARARGS, "Vector_int___getslice__(Vector_int self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j) -> Vector_int"},
	 { "Vector_int___setslice__", _wrap_Vector_int___setslice__, METH_VARARGS, "\n"
		"Vector_int___setslice__(Vector_int self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)\n"
		"Vector_int___setslice__(Vector_int self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j, Vector_int v)\n"
		""},
	 { "Vector_int___delslice__", _wrap_Vector_int___delslice__, METH_VARARGS, "Vector_int___delslice__(Vector_int self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)"},
	 { "Vector_int___delitem__", _wrap_Vector_int___delitem__, METH_VARARGS, "\n"
		"Vector_int___delitem__(Vector_int self, std::vector< unsigned int >::difference_type i)\n"
		"Vector_int___delitem__(Vector_int self, PySliceObject * slice)\n"
		""},
	 { "Vector_int___getitem__", _wrap_Vector_int___getitem__, METH_VARARGS, "\n"
		"Vector_int___getitem__(Vector_int self, PySliceObject * slice) -> Vector_int\n"
		"Vector_int___getitem__(Vector_int self, std::vector< unsigned int >::difference_type i) -> std::vector< unsigned int >::value_type const &\n"
		""},
	 { "Vector_int___setitem__", _wrap_Vector_int___setitem__, METH_VARARGS, "\n"
		"Vector_int___setitem__(Vector_int self, PySliceObject * slice, Vector_int v)\n"
		"Vector_int___setitem__(Vector_int self, PySliceObject * slice)\n"
		"Vector_int___setitem__(Vector_int self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::value_type const & x)\n"
		""},
	 { "Vector_int_pop", _wrap_Vector_int_pop, METH_O, "Vector_int_pop(Vector_int self) -> std::vector< unsigned int >::value_type"},
	 { "Vector_int_append", _wrap_Vector_int_append, METH_VARARGS, "Vector_int_append(Vector_int self, std::vector< unsigned int >::value_type const & x)"},
	 { "Vector_int_empty", _wrap_Vector_int_empty, METH_O, "Vector_int_empty(Vector_int self) -> bool"},
	 { "Vector_int_size", _wrap_Vector_int_size, METH_O, "Vector_int_size(Vector_int self) -> std::vector< unsigned int >::size_type"},
	 { "Vector_int_swap", _wrap_Vector_int_swap, METH_VARARGS, "Vector_int_swap(Vector_int self, Vector_int v)"},
	 { "Vector_int_begin", _wrap_Vector_int_begin, METH_O, "Vector_int_begin(Vector_int self) -> std::vector< unsigned int >::iterator"},
	 { "Vector_int_end", _wrap_Vector_int_end, METH_O, "Vector_int_end(Vector_int self) -> std::vector< unsigned int >::iterator"},
	 { "Vector_int_rbegin", _wrap_Vector_int_rbegin, METH_O, "Vector_int_rbegin(Vector_int self) -> std::vector< unsigned int >::reverse_iterator"},
	 { "Vector_int_rend", _wrap_Vector_int_rend, METH_O, "Vector_int_rend(Vector_int self) -> std::vector< unsigned int >::reverse_iterator"},
	 { "Vector_int_clear", _wrap_Vector_int_clear, METH_O, "Vector_int_clear(Vector_int self)"},
	 { "Vector_int_get_allocator", _wrap_Vector_int_get_allocator, METH_O, "Vector_int_get_allocator(Vector_int self) -> std::vector< unsigned int >::allocator_type"},
	 { "Vector_int_pop_back", _wrap_Vector_int_pop_back, METH_O, "Vector_int_pop_back(Vector_int self)"},
	 { "Vector_int_erase", _wrap_Vector_int_erase, METH_VARARGS, "\n"
		"Vector_int_erase(Vector_int self, std::vector< unsigned int >::iterator pos) -> std::vector< unsigned int >::iterator\n"
		"Vector_int_erase(Vector_int self, std::vector< unsigned int >::iterator first, std::vector< unsigned int >::iterator last) -> std::vector< unsigned int >::iterator\n"
		""},
	 { "new_Vector_int", _wrap_new_Vector_int, METH_VARARGS, "\n"
		"Vector_int()\n"
		"Vector_int(Vector_int arg1)\n"
		"Vector_int(std::vector< unsigned int >::size_type size)\n"
		"new_Vector_int(std::vector< unsigned int >::size_type size, std::vector< unsigned int >::value_type const & value) -> Vector_int\n"
		""},
	 { "Vector_int_push_back", _wrap_Vector_int_push_back, METH_VARARGS, "Vector_int_push_back(Vector_int self, std::vector< unsigned int >::value_type const & x)"},
	 { "Vector_int_front", _wrap_Vector_int_front, METH_O, "Vector_int_front(Vector_int self) -> std::vector< unsigned int >::value_type const &"},
	 { "Vector_int_back", _wrap_Vector_int_back, METH_O, "Vector_int_back(Vector_int self) -> std::vector< unsigned int >::value_type const &"},
	 { "Vector_int_assign", _wrap_Vector_int_assign, METH_VARARGS, "Vector_int_assign(Vector_int self, std::vector< unsigned int >::size_type n, std::vector< unsigned int >::value_type const & x)"},
	 { "Vector_int_resize", _wrap_Vector_int_resize, METH_VARARGS, "\n"
		"Vector_int_resize(Vector_int self, std::vector< unsigned int >::size_type new_size)\n"
		"Vector_int_resize(Vector_int self, std::vector< unsigned int >::size_type new_size, std::vector< unsigned int >::value_type const & x)\n"
		""},
	 { "Vector_int_insert", _wrap_Vector_int_insert, METH_VARARGS, "\n"
		"Vector_int_insert(Vector_int self, std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::value_type const & x) -> std::vector< unsigned int >::iterator\n"
		"Vector_int_insert(Vector_int self, std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::size_type n, std::vector< unsigned int >::value_type const & x)\n"
		""},
	 { "Vector_int_reserve", _wrap_Vector_int_reserve, METH_VARARGS, "Vector_int_reserve(Vector_int self, std::vector< unsigned int >::size_type n)"},
	 { "Vector_int_capacity", _wrap_Vector_int_capacity, METH_O, "Vector_int_capacity(Vector_int self) -> std::vector< unsigned int >::size_type"},
	 { "delete_Vector_int", _wrap_delete_Vector_int, METH_O, "delete_Vector_int(Vector_int self)"},
	 { "Vector_int_swigregister", Vector_int_swigregister, METH_VARARGS, NULL},
	 { "Vector_int_swiginit", Vector_int_swiginit, METH_VARARGS, NULL},
	 { "Vector_string_iterator", _wrap_Vector_string_iterator, METH_O, "Vector_string_iterator(Vector_string self) -> SwigPyIterator"},
	 { "Vector_string___nonzero__", _wrap_Vector_string___nonzero__, METH_O, "Vector_string___nonzero__(Vector_string self) -> bool"},
	 { "Vector_string___bool__", _wrap_Vector_string___bool__, METH_O, "Vector_string___bool__(Vector_string self) -> bool"},
	 { "Vector_string___len__", _wrap_Vector_string___len__, METH_O, "Vector_string___len__(Vector_string self) -> std::vector< std::string >::size_type"},
	 { "Vector_string___getslice__", _wrap_Vector_string___getslice__, METH_VARARGS, "Vector_string___getslice__(Vector_string self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> Vector_string"},
	 { "Vector_string___setslice__", _wrap_Vector_string___setslice__, METH_VARARGS, "\n"
		"Vector_string___setslice__(Vector_string self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)\n"
		"Vector_string___setslice__(Vector_string self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, Vector_string v)\n"
		""},
	 { "Vector_string___delslice__", _wrap_Vector_string___delslice__, METH_VARARGS, "Vector_string___delslice__(Vector_string self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"},
	 { "Vector_string___delitem__", _wrap_Vector_string___delitem__, METH_VARARGS, "\n"
		"Vector_string___delitem__(Vector_string self, std::vector< std::string >::difference_type i)\n"
		"Vector_string___delitem__(Vector_string self, PySliceObject * slice)\n"
		""},
	 { "Vector_string___getitem__", _wrap_Vector_string___getitem__, METH_VARARGS, "\n"
		"Vector_string___getitem__(Vector_string self, PySliceObject * slice) -> Vector_string\n"
		"Vector_string___getitem__(Vector_string self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &\n"
		""},
	 { "Vector_string___setitem__", _wrap_Vector_string___setitem__, METH_VARARGS, "\n"
		"Vector_string___setitem__(Vector_string self, PySliceObject * slice, Vector_string v)\n"
		"Vector_string___setitem__(Vector_string self, PySliceObject * slice)\n"
		"Vector_string___setitem__(Vector_string self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)\n"
		""},
	 { "Vector_string_pop", _wrap_Vector_string_pop, METH_O, "Vector_string_pop(Vector_string self) -> std::vector< std::string >::value_type"},
	 { "Vector_string_append", _wrap_Vector_string_append, METH_VARARGS, "Vector_string_append(Vector_string self, std::vector< std::string >::value_type const & x)"},
	 { "Vector_string_empty", _wrap_Vector_string_empty, METH_O, "Vector_string_empty(Vector_string self) -> bool"},
	 { "Vector_string_size", _wrap_Vector_string_size, METH_O, "Vector_string_size(Vector_string self) -> std::vector< std::string >::size_type"},
	 { "Vector_string_swap", _wrap_Vector_string_swap, METH_VARARGS, "Vector_string_swap(Vector_string self, Vector_string v)"},
	 { "Vector_string_begin", _wrap_Vector_string_begin, METH_O, "Vector_string_begin(Vector_string self) -> std::vector< std::string >::iterator"},
	 { "Vector_string_end", _wrap_Vector_string_end, METH_O, "Vector_string_end(Vector_string self) -> std::vector< std::string >::iterator"},
	 { "Vector_string_rbegin", _wrap_Vector_string_rbegin, METH_O, "Vector_string_rbegin(Vector_string self) -> std::vector< std::string >::reverse_iterator"},
	 { "Vector_string_rend", _wrap_Vector_string_rend, METH_O, "Vector_string_rend(Vector_string self) -> std::vector< std::string >::reverse_iterator"},
	 { "Vector_string_clear", _wrap_Vector_string_clear, METH_O, "Vector_string_clear(Vector_string self)"},
	 { "Vector_string_get_allocator", _wrap_Vector_string_get_allocator, METH_O, "Vector_string_get_allocator(Vector_string self) -> std::vector< std::string >::allocator_type"},
	 { "Vector_string_pop_back", _wrap_Vector_string_pop_back, METH_O, "Vector_string_pop_back(Vector_string self)"},
	 { "Vector_string_erase", _wrap_Vector_string_erase, METH_VARARGS, "\n"
		"Vector_string_erase(Vector_string self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator\n"
		"Vector_string_erase(Vector_string self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator\n"
		""},
	 { "new_Vector_string", _wrap_new_Vector_string, METH_VARARGS, "\n"
		"Vector_string()\n"
		"Vector_string(Vector_string arg1)\n"
		"Vector_string(std::vector< std::string >::size_type size)\n"
		"new_Vector_string(std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> Vector_string\n"
		""},
	 { "Vector_string_push_back", _wrap_Vector_string_push_back, METH_VARARGS, "Vector_string_push_back(Vector_string self, std::vector< std::string >::value_type const & x)"},
	 { "Vector_string_front", _wrap_Vector_string_front, METH_O, "Vector_string_front(Vector_string self) -> std::vector< std::string >::value_type const &"},
	 { "Vector_string_back", _wrap_Vector_string_back, METH_O, "Vector_string_back(Vector_string self) -> std::vector< std::string >::value_type const &"},
	 { "Vector_string_assign", _wrap_Vector_string_assign, METH_VARARGS, "Vector_string_assign(Vector_string self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"},
	 { "Vector_string_resize", _wrap_Vector_string_resize, METH_VARARGS, "\n"
		"Vector_string_resize(Vector_string self, std::vector< std::string >::size_type new_size)\n"
		"Vector_string_resize(Vector_string self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)\n"
		""},
	 { "Vector_string_insert", _wrap_Vector_string_insert, METH_VARARGS, "\n"
		"Vector_string_insert(Vector_string self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator\n"
		"Vector_string_insert(Vector_string self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)\n"
		""},
	 { "Vector_string_reserve", _wrap_Vector_string_reserve, METH_VARARGS, "Vector_string_reserve(Vector_string self, std::vector< std::string >::size_type n)"},
	 { "Vector_string_capacity", _wrap_Vector_string_capacity, METH_O, "Vector_string_capacity(Vector_string self) -> std::vector< std::string >::size_type"},
	 { "delete_Vector_string", _wrap_delete_Vector_string, METH_O, "delete_Vector_string(Vector_string self)"},
	 { "Vector_string_swigregister", Vector_string_swigregister, METH_VARARGS, NULL},
	 { "Vector_string_swiginit", Vector_string_swiginit, METH_VARARGS, NULL},
	 { "new_SetIteratorStaticEnd", _wrap_new_SetIteratorStaticEnd, METH_NOARGS, "new_SetIteratorStaticEnd() -> SetIteratorStaticEnd"},
	 { "delete_SetIteratorStaticEnd", _wrap_delete_SetIteratorStaticEnd, METH_O, "delete_SetIteratorStaticEnd(SetIteratorStaticEnd self)"},
	 { "SetIteratorStaticEnd_swigregister", SetIteratorStaticEnd_swigregister, METH_VARARGS, NULL},
	 { "SetIteratorStaticEnd_swiginit", SetIteratorStaticEnd_swiginit, METH_VARARGS, NULL},
	 { "new_GumException", _wrap_new_GumException, METH_VARARGS, "\n"
		"Exception(std::string const aMsg=\"\", std::string const aType=\"Generic error\")\n"
		"new_GumException(GumException e) -> GumException\n"
		""},
	 { "delete_GumException", _wrap_delete_GumException, METH_O, "delete_GumException(GumException self)"},
	 { "GumException_what", _wrap_GumException_what, METH_O, "GumException_what(GumException self) -> std::string const"},
	 { "GumException_errorContent", _wrap_GumException_errorContent, METH_O, "\n"
		"GumException_errorContent(GumException self) -> std::string const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the error content\n"
		"\n"
		""},
	 { "GumException_errorType", _wrap_GumException_errorType, METH_O, "\n"
		"GumException_errorType(GumException self) -> std::string const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the error type\n"
		"\n"
		""},
	 { "GumException_errorCallStack", _wrap_GumException_errorCallStack, METH_O, "\n"
		"GumException_errorCallStack(GumException self) -> std::string const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the error call stack\n"
		"\n"
		""},
	 { "GumException_swigregister", GumException_swigregister, METH_VARARGS, NULL},
	 { "GumException_swiginit", GumException_swiginit, METH_VARARGS, NULL},
	 { "__createMsg", _wrap___createMsg, METH_VARARGS, "__createMsg(std::string const & filename, std::string const & function, int const line, std::string const & msg) -> std::string const"},
	 { "new_IdError", _wrap_new_IdError, METH_VARARGS, "\n"
		"IdError(std::string aMsg, std::string aType=\"ID error\")\n"
		"new_IdError(IdError src) -> IdError\n"
		""},
	 { "delete_IdError", _wrap_delete_IdError, METH_O, "delete_IdError(IdError self)"},
	 { "IdError_swigregister", IdError_swigregister, METH_VARARGS, NULL},
	 { "IdError_swiginit", IdError_swiginit, METH_VARARGS, NULL},
	 { "new_FatalError", _wrap_new_FatalError, METH_VARARGS, "\n"
		"FatalError(std::string aMsg, std::string aType=\"Fatal error\")\n"
		"new_FatalError(FatalError src) -> FatalError\n"
		""},
	 { "delete_FatalError", _wrap_delete_FatalError, METH_O, "delete_FatalError(FatalError self)"},
	 { "FatalError_swigregister", FatalError_swigregister, METH_VARARGS, NULL},
	 { "FatalError_swiginit", FatalError_swiginit, METH_VARARGS, NULL},
	 { "new_NotImplementedYet", _wrap_new_NotImplementedYet, METH_VARARGS, "\n"
		"NotImplementedYet(std::string aMsg, std::string aType=\"Not implemented yet\")\n"
		"new_NotImplementedYet(NotImplementedYet src) -> NotImplementedYet\n"
		""},
	 { "delete_NotImplementedYet", _wrap_delete_NotImplementedYet, METH_O, "delete_NotImplementedYet(NotImplementedYet self)"},
	 { "NotImplementedYet_swigregister", NotImplementedYet_swigregister, METH_VARARGS, NULL},
	 { "NotImplementedYet_swiginit", NotImplementedYet_swiginit, METH_VARARGS, NULL},
	 { "new_UndefinedIteratorValue", _wrap_new_UndefinedIteratorValue, METH_VARARGS, "\n"
		"UndefinedIteratorValue(std::string aMsg, std::string aType=\"Undefined iterator\")\n"
		"new_UndefinedIteratorValue(UndefinedIteratorValue src) -> UndefinedIteratorValue\n"
		""},
	 { "delete_UndefinedIteratorValue", _wrap_delete_UndefinedIteratorValue, METH_O, "delete_UndefinedIteratorValue(UndefinedIteratorValue self)"},
	 { "UndefinedIteratorValue_swigregister", UndefinedIteratorValue_swigregister, METH_VARARGS, NULL},
	 { "UndefinedIteratorValue_swiginit", UndefinedIteratorValue_swiginit, METH_VARARGS, NULL},
	 { "new_UndefinedIteratorKey", _wrap_new_UndefinedIteratorKey, METH_VARARGS, "\n"
		"UndefinedIteratorKey(std::string aMsg, std::string aType=\"Undefined iterator\\'s key\")\n"
		"new_UndefinedIteratorKey(UndefinedIteratorKey src) -> UndefinedIteratorKey\n"
		""},
	 { "delete_UndefinedIteratorKey", _wrap_delete_UndefinedIteratorKey, METH_O, "delete_UndefinedIteratorKey(UndefinedIteratorKey self)"},
	 { "UndefinedIteratorKey_swigregister", UndefinedIteratorKey_swigregister, METH_VARARGS, NULL},
	 { "UndefinedIteratorKey_swiginit", UndefinedIteratorKey_swiginit, METH_VARARGS, NULL},
	 { "new_NullElement", _wrap_new_NullElement, METH_VARARGS, "\n"
		"NullElement(std::string aMsg, std::string aType=\"Null element\")\n"
		"new_NullElement(NullElement src) -> NullElement\n"
		""},
	 { "delete_NullElement", _wrap_delete_NullElement, METH_O, "delete_NullElement(NullElement self)"},
	 { "NullElement_swigregister", NullElement_swigregister, METH_VARARGS, NULL},
	 { "NullElement_swiginit", NullElement_swiginit, METH_VARARGS, NULL},
	 { "new_UndefinedElement", _wrap_new_UndefinedElement, METH_VARARGS, "\n"
		"UndefinedElement(std::string aMsg, std::string aType=\"Undefined element\")\n"
		"new_UndefinedElement(UndefinedElement src) -> UndefinedElement\n"
		""},
	 { "delete_UndefinedElement", _wrap_delete_UndefinedElement, METH_O, "delete_UndefinedElement(UndefinedElement self)"},
	 { "UndefinedElement_swigregister", UndefinedElement_swigregister, METH_VARARGS, NULL},
	 { "UndefinedElement_swiginit", UndefinedElement_swiginit, METH_VARARGS, NULL},
	 { "new_SizeError", _wrap_new_SizeError, METH_VARARGS, "\n"
		"SizeError(std::string aMsg, std::string aType=\"incorrect size\")\n"
		"new_SizeError(SizeError src) -> SizeError\n"
		""},
	 { "delete_SizeError", _wrap_delete_SizeError, METH_O, "delete_SizeError(SizeError self)"},
	 { "SizeError_swigregister", SizeError_swigregister, METH_VARARGS, NULL},
	 { "SizeError_swiginit", SizeError_swiginit, METH_VARARGS, NULL},
	 { "new_EmptySet", _wrap_new_EmptySet, METH_VARARGS, "\n"
		"EmptySet(std::string aMsg, std::string aType=\"Empty set\")\n"
		"new_EmptySet(EmptySet src) -> EmptySet\n"
		""},
	 { "delete_EmptySet", _wrap_delete_EmptySet, METH_O, "delete_EmptySet(EmptySet self)"},
	 { "EmptySet_swigregister", EmptySet_swigregister, METH_VARARGS, NULL},
	 { "EmptySet_swiginit", EmptySet_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidArgumentsNumber", _wrap_new_InvalidArgumentsNumber, METH_VARARGS, "\n"
		"InvalidArgumentsNumber(std::string aMsg, std::string aType=\"Invalid argument number\")\n"
		"new_InvalidArgumentsNumber(InvalidArgumentsNumber src) -> InvalidArgumentsNumber\n"
		""},
	 { "delete_InvalidArgumentsNumber", _wrap_delete_InvalidArgumentsNumber, METH_O, "delete_InvalidArgumentsNumber(InvalidArgumentsNumber self)"},
	 { "InvalidArgumentsNumber_swigregister", InvalidArgumentsNumber_swigregister, METH_VARARGS, NULL},
	 { "InvalidArgumentsNumber_swiginit", InvalidArgumentsNumber_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidArgument", _wrap_new_InvalidArgument, METH_VARARGS, "\n"
		"InvalidArgument(std::string aMsg, std::string aType=\"Invalid argument\")\n"
		"new_InvalidArgument(InvalidArgument src) -> InvalidArgument\n"
		""},
	 { "delete_InvalidArgument", _wrap_delete_InvalidArgument, METH_O, "delete_InvalidArgument(InvalidArgument self)"},
	 { "InvalidArgument_swigregister", InvalidArgument_swigregister, METH_VARARGS, NULL},
	 { "InvalidArgument_swiginit", InvalidArgument_swiginit, METH_VARARGS, NULL},
	 { "new_IOError", _wrap_new_IOError, METH_VARARGS, "\n"
		"IOError(std::string aMsg, std::string aType=\"I/O Error\")\n"
		"new_IOError(IOError src) -> IOError\n"
		""},
	 { "delete_IOError", _wrap_delete_IOError, METH_O, "delete_IOError(IOError self)"},
	 { "IOError_swigregister", IOError_swigregister, METH_VARARGS, NULL},
	 { "IOError_swiginit", IOError_swiginit, METH_VARARGS, NULL},
	 { "new_FormatNotFound", _wrap_new_FormatNotFound, METH_VARARGS, "\n"
		"FormatNotFound(std::string aMsg, std::string aType=\"Format not found\")\n"
		"new_FormatNotFound(FormatNotFound src) -> FormatNotFound\n"
		""},
	 { "delete_FormatNotFound", _wrap_delete_FormatNotFound, METH_O, "delete_FormatNotFound(FormatNotFound self)"},
	 { "FormatNotFound_swigregister", FormatNotFound_swigregister, METH_VARARGS, NULL},
	 { "FormatNotFound_swiginit", FormatNotFound_swiginit, METH_VARARGS, NULL},
	 { "new_OperationNotAllowed", _wrap_new_OperationNotAllowed, METH_VARARGS, "\n"
		"OperationNotAllowed(std::string aMsg, std::string aType=\"Operation not allowed\")\n"
		"new_OperationNotAllowed(OperationNotAllowed src) -> OperationNotAllowed\n"
		""},
	 { "delete_OperationNotAllowed", _wrap_delete_OperationNotAllowed, METH_O, "delete_OperationNotAllowed(OperationNotAllowed self)"},
	 { "OperationNotAllowed_swigregister", OperationNotAllowed_swigregister, METH_VARARGS, NULL},
	 { "OperationNotAllowed_swiginit", OperationNotAllowed_swiginit, METH_VARARGS, NULL},
	 { "new_NotFound", _wrap_new_NotFound, METH_VARARGS, "\n"
		"NotFound(std::string aMsg, std::string aType=\"Object not found\")\n"
		"new_NotFound(NotFound src) -> NotFound\n"
		""},
	 { "delete_NotFound", _wrap_delete_NotFound, METH_O, "delete_NotFound(NotFound self)"},
	 { "NotFound_swigregister", NotFound_swigregister, METH_VARARGS, NULL},
	 { "NotFound_swiginit", NotFound_swiginit, METH_VARARGS, NULL},
	 { "new_ReferenceError", _wrap_new_ReferenceError, METH_VARARGS, "\n"
		"ReferenceError(std::string aMsg, std::string aType=\"Reference error\")\n"
		"new_ReferenceError(ReferenceError src) -> ReferenceError\n"
		""},
	 { "delete_ReferenceError", _wrap_delete_ReferenceError, METH_O, "delete_ReferenceError(ReferenceError self)"},
	 { "ReferenceError_swigregister", ReferenceError_swigregister, METH_VARARGS, NULL},
	 { "ReferenceError_swiginit", ReferenceError_swiginit, METH_VARARGS, NULL},
	 { "new_OutOfBounds", _wrap_new_OutOfBounds, METH_VARARGS, "\n"
		"OutOfBounds(std::string aMsg, std::string aType=\"Out of bound error\")\n"
		"new_OutOfBounds(OutOfBounds src) -> OutOfBounds\n"
		""},
	 { "delete_OutOfBounds", _wrap_delete_OutOfBounds, METH_O, "delete_OutOfBounds(OutOfBounds self)"},
	 { "OutOfBounds_swigregister", OutOfBounds_swigregister, METH_VARARGS, NULL},
	 { "OutOfBounds_swiginit", OutOfBounds_swiginit, METH_VARARGS, NULL},
	 { "new_OutOfLowerBound", _wrap_new_OutOfLowerBound, METH_VARARGS, "\n"
		"OutOfLowerBound(std::string aMsg, std::string aType=\"Out of lower bound error\")\n"
		"new_OutOfLowerBound(OutOfLowerBound src) -> OutOfLowerBound\n"
		""},
	 { "delete_OutOfLowerBound", _wrap_delete_OutOfLowerBound, METH_O, "delete_OutOfLowerBound(OutOfLowerBound self)"},
	 { "OutOfLowerBound_swigregister", OutOfLowerBound_swigregister, METH_VARARGS, NULL},
	 { "OutOfLowerBound_swiginit", OutOfLowerBound_swiginit, METH_VARARGS, NULL},
	 { "new_OutOfUpperBound", _wrap_new_OutOfUpperBound, METH_VARARGS, "\n"
		"OutOfUpperBound(std::string aMsg, std::string aType=\"Out of upper bound error\")\n"
		"new_OutOfUpperBound(OutOfUpperBound src) -> OutOfUpperBound\n"
		""},
	 { "delete_OutOfUpperBound", _wrap_delete_OutOfUpperBound, METH_O, "delete_OutOfUpperBound(OutOfUpperBound self)"},
	 { "OutOfUpperBound_swigregister", OutOfUpperBound_swigregister, METH_VARARGS, NULL},
	 { "OutOfUpperBound_swiginit", OutOfUpperBound_swiginit, METH_VARARGS, NULL},
	 { "new_DuplicateElement", _wrap_new_DuplicateElement, METH_VARARGS, "\n"
		"DuplicateElement(std::string aMsg, std::string aType=\"Duplicate element\")\n"
		"new_DuplicateElement(DuplicateElement src) -> DuplicateElement\n"
		""},
	 { "delete_DuplicateElement", _wrap_delete_DuplicateElement, METH_O, "delete_DuplicateElement(DuplicateElement self)"},
	 { "DuplicateElement_swigregister", DuplicateElement_swigregister, METH_VARARGS, NULL},
	 { "DuplicateElement_swiginit", DuplicateElement_swiginit, METH_VARARGS, NULL},
	 { "new_DuplicateLabel", _wrap_new_DuplicateLabel, METH_VARARGS, "\n"
		"DuplicateLabel(std::string aMsg, std::string aType=\"Duplicate label\")\n"
		"new_DuplicateLabel(DuplicateLabel src) -> DuplicateLabel\n"
		""},
	 { "delete_DuplicateLabel", _wrap_delete_DuplicateLabel, METH_O, "delete_DuplicateLabel(DuplicateLabel self)"},
	 { "DuplicateLabel_swigregister", DuplicateLabel_swigregister, METH_VARARGS, NULL},
	 { "DuplicateLabel_swiginit", DuplicateLabel_swiginit, METH_VARARGS, NULL},
	 { "new_GraphError", _wrap_new_GraphError, METH_VARARGS, "\n"
		"GraphError(std::string aMsg, std::string aType=\"Graph error\")\n"
		"new_GraphError(GraphError src) -> GraphError\n"
		""},
	 { "delete_GraphError", _wrap_delete_GraphError, METH_O, "delete_GraphError(GraphError self)"},
	 { "GraphError_swigregister", GraphError_swigregister, METH_VARARGS, NULL},
	 { "GraphError_swiginit", GraphError_swiginit, METH_VARARGS, NULL},
	 { "new_NoNeighbour", _wrap_new_NoNeighbour, METH_VARARGS, "\n"
		"NoNeighbour(std::string aMsg, std::string aType=\"No neighbour found\")\n"
		"new_NoNeighbour(NoNeighbour src) -> NoNeighbour\n"
		""},
	 { "delete_NoNeighbour", _wrap_delete_NoNeighbour, METH_O, "delete_NoNeighbour(NoNeighbour self)"},
	 { "NoNeighbour_swigregister", NoNeighbour_swigregister, METH_VARARGS, NULL},
	 { "NoNeighbour_swiginit", NoNeighbour_swiginit, METH_VARARGS, NULL},
	 { "new_NoParent", _wrap_new_NoParent, METH_VARARGS, "\n"
		"NoParent(std::string aMsg, std::string aType=\"No parent found\")\n"
		"new_NoParent(NoParent src) -> NoParent\n"
		""},
	 { "delete_NoParent", _wrap_delete_NoParent, METH_O, "delete_NoParent(NoParent self)"},
	 { "NoParent_swigregister", NoParent_swigregister, METH_VARARGS, NULL},
	 { "NoParent_swiginit", NoParent_swiginit, METH_VARARGS, NULL},
	 { "new_NoChild", _wrap_new_NoChild, METH_VARARGS, "\n"
		"NoChild(std::string aMsg, std::string aType=\"No child found\")\n"
		"new_NoChild(NoChild src) -> NoChild\n"
		""},
	 { "delete_NoChild", _wrap_delete_NoChild, METH_O, "delete_NoChild(NoChild self)"},
	 { "NoChild_swigregister", NoChild_swigregister, METH_VARARGS, NULL},
	 { "NoChild_swiginit", NoChild_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidEdge", _wrap_new_InvalidEdge, METH_VARARGS, "\n"
		"InvalidEdge(std::string aMsg, std::string aType=\"Edge invalid\")\n"
		"new_InvalidEdge(InvalidEdge src) -> InvalidEdge\n"
		""},
	 { "delete_InvalidEdge", _wrap_delete_InvalidEdge, METH_O, "delete_InvalidEdge(InvalidEdge self)"},
	 { "InvalidEdge_swigregister", InvalidEdge_swigregister, METH_VARARGS, NULL},
	 { "InvalidEdge_swiginit", InvalidEdge_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidArc", _wrap_new_InvalidArc, METH_VARARGS, "\n"
		"InvalidArc(std::string aMsg, std::string aType=\"Arc invalid\")\n"
		"new_InvalidArc(InvalidArc src) -> InvalidArc\n"
		""},
	 { "delete_InvalidArc", _wrap_delete_InvalidArc, METH_O, "delete_InvalidArc(InvalidArc self)"},
	 { "InvalidArc_swigregister", InvalidArc_swigregister, METH_VARARGS, NULL},
	 { "InvalidArc_swiginit", InvalidArc_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidNode", _wrap_new_InvalidNode, METH_VARARGS, "\n"
		"InvalidNode(std::string aMsg, std::string aType=\"Node invalid\")\n"
		"new_InvalidNode(InvalidNode src) -> InvalidNode\n"
		""},
	 { "delete_InvalidNode", _wrap_delete_InvalidNode, METH_O, "delete_InvalidNode(InvalidNode self)"},
	 { "InvalidNode_swigregister", InvalidNode_swigregister, METH_VARARGS, NULL},
	 { "InvalidNode_swiginit", InvalidNode_swiginit, METH_VARARGS, NULL},
	 { "new_EmptyBSTree", _wrap_new_EmptyBSTree, METH_VARARGS, "\n"
		"EmptyBSTree(std::string aMsg, std::string aType=\"Empty binary search tree\")\n"
		"new_EmptyBSTree(EmptyBSTree src) -> EmptyBSTree\n"
		""},
	 { "delete_EmptyBSTree", _wrap_delete_EmptyBSTree, METH_O, "delete_EmptyBSTree(EmptyBSTree self)"},
	 { "EmptyBSTree_swigregister", EmptyBSTree_swigregister, METH_VARARGS, NULL},
	 { "EmptyBSTree_swiginit", EmptyBSTree_swiginit, METH_VARARGS, NULL},
	 { "new_DefaultInLabel", _wrap_new_DefaultInLabel, METH_VARARGS, "\n"
		"DefaultInLabel(std::string aMsg, std::string aType=\"Error on label\")\n"
		"new_DefaultInLabel(DefaultInLabel src) -> DefaultInLabel\n"
		""},
	 { "delete_DefaultInLabel", _wrap_delete_DefaultInLabel, METH_O, "delete_DefaultInLabel(DefaultInLabel self)"},
	 { "DefaultInLabel_swigregister", DefaultInLabel_swigregister, METH_VARARGS, NULL},
	 { "DefaultInLabel_swiginit", DefaultInLabel_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidDirectedCycle", _wrap_new_InvalidDirectedCycle, METH_VARARGS, "\n"
		"InvalidDirectedCycle(std::string aMsg, std::string aType=\"Directed cycle detected\")\n"
		"new_InvalidDirectedCycle(InvalidDirectedCycle src) -> InvalidDirectedCycle\n"
		""},
	 { "delete_InvalidDirectedCycle", _wrap_delete_InvalidDirectedCycle, METH_O, "delete_InvalidDirectedCycle(InvalidDirectedCycle self)"},
	 { "InvalidDirectedCycle_swigregister", InvalidDirectedCycle_swigregister, METH_VARARGS, NULL},
	 { "InvalidDirectedCycle_swiginit", InvalidDirectedCycle_swiginit, METH_VARARGS, NULL},
	 { "new_CPTError", _wrap_new_CPTError, METH_VARARGS, "\n"
		"CPTError(std::string aMsg, std::string aType=\"CPT error\")\n"
		"new_CPTError(CPTError src) -> CPTError\n"
		""},
	 { "delete_CPTError", _wrap_delete_CPTError, METH_O, "delete_CPTError(CPTError self)"},
	 { "CPTError_swigregister", CPTError_swigregister, METH_VARARGS, NULL},
	 { "CPTError_swiginit", CPTError_swiginit, METH_VARARGS, NULL},
	 { "new_CPTNoSumTo1", _wrap_new_CPTNoSumTo1, METH_VARARGS, "\n"
		"CPTNoSumTo1(std::string aMsg, std::string aType=\"CPT does not sum to 1\")\n"
		"new_CPTNoSumTo1(CPTNoSumTo1 src) -> CPTNoSumTo1\n"
		""},
	 { "delete_CPTNoSumTo1", _wrap_delete_CPTNoSumTo1, METH_O, "delete_CPTNoSumTo1(CPTNoSumTo1 self)"},
	 { "CPTNoSumTo1_swigregister", CPTNoSumTo1_swigregister, METH_VARARGS, NULL},
	 { "CPTNoSumTo1_swiginit", CPTNoSumTo1_swiginit, METH_VARARGS, NULL},
	 { "new_IncompatibleEvidence", _wrap_new_IncompatibleEvidence, METH_VARARGS, "\n"
		"IncompatibleEvidence(std::string aMsg, std::string aType=\"several evidence/CPT are incompatible together (proba=0)\")\n"
		"new_IncompatibleEvidence(IncompatibleEvidence src) -> IncompatibleEvidence\n"
		""},
	 { "delete_IncompatibleEvidence", _wrap_delete_IncompatibleEvidence, METH_O, "delete_IncompatibleEvidence(IncompatibleEvidence self)"},
	 { "IncompatibleEvidence_swigregister", IncompatibleEvidence_swigregister, METH_VARARGS, NULL},
	 { "IncompatibleEvidence_swiginit", IncompatibleEvidence_swiginit, METH_VARARGS, NULL},
	 { "new_FactoryError", _wrap_new_FactoryError, METH_VARARGS, "\n"
		"FactoryError(std::string aMsg, std::string aType=\"factory error\")\n"
		"new_FactoryError(FactoryError src) -> FactoryError\n"
		""},
	 { "delete_FactoryError", _wrap_delete_FactoryError, METH_O, "delete_FactoryError(FactoryError self)"},
	 { "FactoryError_swigregister", FactoryError_swigregister, METH_VARARGS, NULL},
	 { "FactoryError_swiginit", FactoryError_swiginit, METH_VARARGS, NULL},
	 { "new_FactoryInvalidState", _wrap_new_FactoryInvalidState, METH_VARARGS, "\n"
		"FactoryInvalidState(std::string aMsg, std::string aType=\"invalid state error\")\n"
		"new_FactoryInvalidState(FactoryInvalidState src) -> FactoryInvalidState\n"
		""},
	 { "delete_FactoryInvalidState", _wrap_delete_FactoryInvalidState, METH_O, "delete_FactoryInvalidState(FactoryInvalidState self)"},
	 { "FactoryInvalidState_swigregister", FactoryInvalidState_swigregister, METH_VARARGS, NULL},
	 { "FactoryInvalidState_swiginit", FactoryInvalidState_swiginit, METH_VARARGS, NULL},
	 { "new_WrongType", _wrap_new_WrongType, METH_VARARGS, "\n"
		"WrongType(std::string aMsg, std::string aType=\"wrong type for this operation\")\n"
		"new_WrongType(WrongType src) -> WrongType\n"
		""},
	 { "delete_WrongType", _wrap_delete_WrongType, METH_O, "delete_WrongType(WrongType self)"},
	 { "WrongType_swigregister", WrongType_swigregister, METH_VARARGS, NULL},
	 { "WrongType_swiginit", WrongType_swiginit, METH_VARARGS, NULL},
	 { "new_WrongClassElement", _wrap_new_WrongClassElement, METH_VARARGS, "\n"
		"WrongClassElement(std::string aMsg, std::string aType=\"Wrong ClassElement\")\n"
		"new_WrongClassElement(WrongClassElement src) -> WrongClassElement\n"
		""},
	 { "delete_WrongClassElement", _wrap_delete_WrongClassElement, METH_O, "delete_WrongClassElement(WrongClassElement self)"},
	 { "WrongClassElement_swigregister", WrongClassElement_swigregister, METH_VARARGS, NULL},
	 { "WrongClassElement_swiginit", WrongClassElement_swiginit, METH_VARARGS, NULL},
	 { "new_TypeError", _wrap_new_TypeError, METH_VARARGS, "\n"
		"TypeError(std::string aMsg, std::string aType=\"Wrong subtype or subclass\")\n"
		"new_TypeError(TypeError src) -> TypeError\n"
		""},
	 { "delete_TypeError", _wrap_delete_TypeError, METH_O, "delete_TypeError(TypeError self)"},
	 { "TypeError_swigregister", TypeError_swigregister, METH_VARARGS, NULL},
	 { "TypeError_swiginit", TypeError_swiginit, METH_VARARGS, NULL},
	 { "new_LearningError", _wrap_new_LearningError, METH_VARARGS, "\n"
		"LearningError(std::string aMsg, std::string aType=\"Factory error\")\n"
		"new_LearningError(LearningError src) -> LearningError\n"
		""},
	 { "delete_LearningError", _wrap_delete_LearningError, METH_O, "delete_LearningError(LearningError self)"},
	 { "LearningError_swigregister", LearningError_swigregister, METH_VARARGS, NULL},
	 { "LearningError_swiginit", LearningError_swiginit, METH_VARARGS, NULL},
	 { "new_IncompatibleScoreApriori", _wrap_new_IncompatibleScoreApriori, METH_VARARGS, "\n"
		"IncompatibleScoreApriori(std::string aMsg, std::string aType=\"Incompatbile (maybe implicit) priors\")\n"
		"new_IncompatibleScoreApriori(IncompatibleScoreApriori src) -> IncompatibleScoreApriori\n"
		""},
	 { "delete_IncompatibleScoreApriori", _wrap_delete_IncompatibleScoreApriori, METH_O, "delete_IncompatibleScoreApriori(IncompatibleScoreApriori self)"},
	 { "IncompatibleScoreApriori_swigregister", IncompatibleScoreApriori_swigregister, METH_VARARGS, NULL},
	 { "IncompatibleScoreApriori_swiginit", IncompatibleScoreApriori_swiginit, METH_VARARGS, NULL},
	 { "new_PossiblyIncompatibleScoreApriori", _wrap_new_PossiblyIncompatibleScoreApriori, METH_VARARGS, "\n"
		"PossiblyIncompatibleScoreApriori(std::string aMsg, std::string aType=\"Possible incompatibilty between score and prior\")\n"
		"new_PossiblyIncompatibleScoreApriori(PossiblyIncompatibleScoreApriori src) -> PossiblyIncompatibleScoreApriori\n"
		""},
	 { "delete_PossiblyIncompatibleScoreApriori", _wrap_delete_PossiblyIncompatibleScoreApriori, METH_O, "delete_PossiblyIncompatibleScoreApriori(PossiblyIncompatibleScoreApriori self)"},
	 { "PossiblyIncompatibleScoreApriori_swigregister", PossiblyIncompatibleScoreApriori_swigregister, METH_VARARGS, NULL},
	 { "PossiblyIncompatibleScoreApriori_swiginit", PossiblyIncompatibleScoreApriori_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseError", _wrap_new_DatabaseError, METH_VARARGS, "\n"
		"DatabaseError(std::string aMsg, std::string aType=\"Database error\")\n"
		"new_DatabaseError(DatabaseError src) -> DatabaseError\n"
		""},
	 { "delete_DatabaseError", _wrap_delete_DatabaseError, METH_O, "delete_DatabaseError(DatabaseError self)"},
	 { "DatabaseError_swigregister", DatabaseError_swigregister, METH_VARARGS, NULL},
	 { "DatabaseError_swiginit", DatabaseError_swiginit, METH_VARARGS, NULL},
	 { "new_MissingVariableInDatabase", _wrap_new_MissingVariableInDatabase, METH_VARARGS, "\n"
		"MissingVariableInDatabase(std::string aMsg, std::string aType=\"Missing variable name in database\")\n"
		"new_MissingVariableInDatabase(MissingVariableInDatabase src) -> MissingVariableInDatabase\n"
		""},
	 { "delete_MissingVariableInDatabase", _wrap_delete_MissingVariableInDatabase, METH_O, "delete_MissingVariableInDatabase(MissingVariableInDatabase self)"},
	 { "MissingVariableInDatabase_swigregister", MissingVariableInDatabase_swigregister, METH_VARARGS, NULL},
	 { "MissingVariableInDatabase_swiginit", MissingVariableInDatabase_swiginit, METH_VARARGS, NULL},
	 { "new_MissingValueInDatabase", _wrap_new_MissingValueInDatabase, METH_VARARGS, "\n"
		"MissingValueInDatabase(std::string aMsg, std::string aType=\"The database contains some missing values\")\n"
		"new_MissingValueInDatabase(MissingValueInDatabase src) -> MissingValueInDatabase\n"
		""},
	 { "delete_MissingValueInDatabase", _wrap_delete_MissingValueInDatabase, METH_O, "delete_MissingValueInDatabase(MissingValueInDatabase self)"},
	 { "MissingValueInDatabase_swigregister", MissingValueInDatabase_swigregister, METH_VARARGS, NULL},
	 { "MissingValueInDatabase_swiginit", MissingValueInDatabase_swiginit, METH_VARARGS, NULL},
	 { "new_UnknownLabelInDatabase", _wrap_new_UnknownLabelInDatabase, METH_VARARGS, "\n"
		"UnknownLabelInDatabase(std::string aMsg, std::string aType=\"Unknown label found in database\")\n"
		"new_UnknownLabelInDatabase(UnknownLabelInDatabase src) -> UnknownLabelInDatabase\n"
		""},
	 { "delete_UnknownLabelInDatabase", _wrap_delete_UnknownLabelInDatabase, METH_O, "delete_UnknownLabelInDatabase(UnknownLabelInDatabase self)"},
	 { "UnknownLabelInDatabase_swigregister", UnknownLabelInDatabase_swigregister, METH_VARARGS, NULL},
	 { "UnknownLabelInDatabase_swiginit", UnknownLabelInDatabase_swiginit, METH_VARARGS, NULL},
	 { "new_SyntaxError", _wrap_new_SyntaxError, METH_VARARGS, "SyntaxError(std::string const & aMsg, gum::Size nol, gum::Size noc, std::string aType=\"Syntax Error\")"},
	 { "SyntaxError_col", _wrap_SyntaxError_col, METH_O, "\n"
		"SyntaxError_col(SyntaxError self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the indice of the colonne of the error\n"
		"\n"
		""},
	 { "SyntaxError_line", _wrap_SyntaxError_line, METH_O, "\n"
		"SyntaxError_line(SyntaxError self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the indice of the line of the error\n"
		"\n"
		""},
	 { "delete_SyntaxError", _wrap_delete_SyntaxError, METH_O, "delete_SyntaxError(SyntaxError self)"},
	 { "SyntaxError_swigregister", SyntaxError_swigregister, METH_VARARGS, NULL},
	 { "SyntaxError_swiginit", SyntaxError_swiginit, METH_VARARGS, NULL},
	 { "randomValue", _wrap_randomValue, METH_VARARGS, "\n"
		"randomValue(gum::Size const max=2) -> gum::Idx\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  a value randomly drawn (0 or 1)\n"
		"\n"
		""},
	 { "randomProba", _wrap_randomProba, METH_NOARGS, "\n"
		"randomProba() -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"    a random number between 0 and 1 included (i.e. a proba). \n"
		"\n"
		""},
	 { "randomGeneratorSeed", _wrap_randomGeneratorSeed, METH_NOARGS, "\n"
		"randomGeneratorSeed() -> unsigned int\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  a randomly generated seed\n"
		"\n"
		""},
	 { "initRandom", _wrap_initRandom, METH_VARARGS, "\n"
		"initRandom(unsigned int seed=0)\n"
		"\n"
		"Initialize random generator seed.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"seed : int\n"
		"  the seed used to initialize the random generator\n"
		"\n"
		""},
	 { "getRandomGenerator", _wrap_getRandomGenerator, METH_VARARGS, "\n"
		"getRandomGenerator(unsigned int seed=0) -> std::default_random_engine\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tbw\n"
		"  the random generator\n"
		"\n"
		""},
	 { "isOMP", _wrap_isOMP, METH_NOARGS, "\n"
		"isOMP() -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if OMP has been set at compilation, False otherwise\n"
		"\n"
		""},
	 { "setNumberOfThreads", _wrap_setNumberOfThreads, METH_O, "\n"
		"setNumberOfThreads(unsigned int number)\n"
		"\n"
		"To avoid spare cycles (less then 100% CPU occupied), use more threads than logical processors (x2 is a good all-around value). \n"
		"\n"
		"Returns\n"
		"-------\n"
		"number : int\n"
		"  the number of threads to be used\n"
		"\n"
		""},
	 { "getMaxNumberOfThreads", _wrap_getMaxNumberOfThreads, METH_NOARGS, "\n"
		"getMaxNumberOfThreads() -> unsigned int\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the max number of threads\n"
		"\n"
		""},
	 { "getThreadNumber", _wrap_getThreadNumber, METH_NOARGS, "\n"
		"getThreadNumber() -> unsigned int\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of thread\n"
		"\n"
		""},
	 { "getNumberOfRunningThreads", _wrap_getNumberOfRunningThreads, METH_NOARGS, "\n"
		"getNumberOfRunningThreads() -> unsigned int\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of running threads\n"
		"\n"
		""},
	 { "getNumberOfLogicalProcessors", _wrap_getNumberOfLogicalProcessors, METH_NOARGS, "\n"
		"getNumberOfLogicalProcessors() -> unsigned int\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of logical processors\n"
		"\n"
		""},
	 { "setNestedParallelism", _wrap_setNestedParallelism, METH_O, "\n"
		"setNestedParallelism(bool value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value : bool\n"
		"  True if nested parallelism should be activated\n"
		"\n"
		""},
	 { "getNestedParallelism", _wrap_getNestedParallelism, METH_NOARGS, "\n"
		"getNestedParallelism() -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if nested parallelism is enabled\n"
		"\n"
		""},
	 { "setDynamicThreadsNumber", _wrap_setDynamicThreadsNumber, METH_O, "\n"
		"setDynamicThreadsNumber(bool value)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"value : bool\n"
		"  True if the number of threads should be dynamic\n"
		"\n"
		""},
	 { "getDynamicThreadsNumber", _wrap_getDynamicThreadsNumber, METH_NOARGS, "\n"
		"getDynamicThreadsNumber() -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if dynamic threads number is enabled\n"
		"\n"
		""},
	 { "delete_Variable", _wrap_delete_Variable, METH_O, "delete_Variable(Variable self)"},
	 { "Variable_clone", _wrap_Variable_clone, METH_O, "\n"
		"Variable_clone(Variable self) -> Variable\n"
		"\n"
		"Copy factory\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DiscreteVariable\n"
		"	a pointer on a new copy of this\n"
		"\n"
		""},
	 { "Variable___eq__", _wrap_Variable___eq__, METH_VARARGS, "Variable___eq__(Variable self, Variable aRV) -> bool"},
	 { "Variable___ne__", _wrap_Variable___ne__, METH_VARARGS, "Variable___ne__(Variable self, Variable aRV) -> bool"},
	 { "Variable_setName", _wrap_Variable_setName, METH_VARARGS, "\n"
		"Variable_setName(Variable self, std::string const & theValue)\n"
		"\n"
		"sets the name of the variable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"theValue : str\n"
		"	the new description of the variable\n"
		"\n"
		""},
	 { "Variable_name", _wrap_Variable_name, METH_O, "\n"
		"Variable_name(Variable self) -> std::string const &\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the name of the variable\n"
		"\n"
		""},
	 { "Variable_setDescription", _wrap_Variable_setDescription, METH_VARARGS, "\n"
		"Variable_setDescription(Variable self, std::string const & theValue)\n"
		"\n"
		"set the description of the variable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"theValue : str\n"
		"	the new description of the variable\n"
		"\n"
		""},
	 { "Variable_description", _wrap_Variable_description, METH_O, "\n"
		"Variable_description(Variable self) -> std::string const &\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the description of the variable\n"
		"\n"
		""},
	 { "Variable_varType", _wrap_Variable_varType, METH_O, "Variable_varType(Variable self) -> gum::VarType"},
	 { "Variable_domain", _wrap_Variable_domain, METH_O, "Variable_domain(Variable self) -> std::string const"},
	 { "Variable_swigregister", Variable_swigregister, METH_VARARGS, NULL},
	 { "delete_DiscreteVariable", _wrap_delete_DiscreteVariable, METH_O, "delete_DiscreteVariable(DiscreteVariable self)"},
	 { "DiscreteVariable_clone", _wrap_DiscreteVariable_clone, METH_O, "\n"
		"DiscreteVariable_clone(DiscreteVariable self) -> DiscreteVariable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DiscreteVariable\n"
		"	a copy of the DiscreteVariable\n"
		"\n"
		""},
	 { "DiscreteVariable_empty", _wrap_DiscreteVariable_empty, METH_O, "\n"
		"DiscreteVariable_empty(DiscreteVariable self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the domain size < 2\n"
		"\n"
		""},
	 { "DiscreteVariable_domainSize", _wrap_DiscreteVariable_domainSize, METH_O, "\n"
		"DiscreteVariable_domainSize(DiscreteVariable self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of modalities in the variable domain\n"
		"\n"
		""},
	 { "DiscreteVariable_labels", _wrap_DiscreteVariable_labels, METH_O, "\n"
		"DiscreteVariable_labels(DiscreteVariable self) -> Vector_string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	a tuple containing the labels\n"
		"\n"
		""},
	 { "DiscreteVariable_numerical", _wrap_DiscreteVariable_numerical, METH_VARARGS, "\n"
		"DiscreteVariable_numerical(DiscreteVariable self, gum::Idx indice) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"indice : int\n"
		"	an index\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the numerical representation of the indice-th value\n"
		"\n"
		""},
	 { "DiscreteVariable_varType", _wrap_DiscreteVariable_varType, METH_O, "\n"
		"DiscreteVariable_varType(DiscreteVariable self) -> gum::VarType\n"
		"\n"
		"returns the type of variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	the type of the variable, 0: DiscretizedVariable, 1: LabelizedVariable, 2: RangeVariable\n"
		"\n"
		""},
	 { "DiscreteVariable___eq__", _wrap_DiscreteVariable___eq__, METH_VARARGS, "DiscreteVariable___eq__(DiscreteVariable self, DiscreteVariable aRV) -> bool"},
	 { "DiscreteVariable___ne__", _wrap_DiscreteVariable___ne__, METH_VARARGS, "DiscreteVariable___ne__(DiscreteVariable self, DiscreteVariable aRV) -> bool"},
	 { "DiscreteVariable_index", _wrap_DiscreteVariable_index, METH_VARARGS, "\n"
		"DiscreteVariable_index(DiscreteVariable self, std::string const & label) -> gum::Idx\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"label : str\n"
		"	a label\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the indice of the label\n"
		"\n"
		""},
	 { "DiscreteVariable_label", _wrap_DiscreteVariable_label, METH_VARARGS, "\n"
		"DiscreteVariable_label(DiscreteVariable self, gum::Idx i) -> std::string\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : int\n"
		"	the index of the label we wish to return\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the indice-th label\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfBound\n"
		"	If the variable does not contain the label\n"
		"\n"
		""},
	 { "DiscreteVariable_toStringWithDescription", _wrap_DiscreteVariable_toStringWithDescription, METH_O, "\n"
		"DiscreteVariable_toStringWithDescription(DiscreteVariable self) -> std::string const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	a description of the variable\n"
		"\n"
		""},
	 { "DiscreteVariable_domain", _wrap_DiscreteVariable_domain, METH_O, "\n"
		"DiscreteVariable_domain(DiscreteVariable self) -> std::string const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the domain of the variable\n"
		"\n"
		""},
	 { "DiscreteVariable___repr__", _wrap_DiscreteVariable___repr__, METH_O, "DiscreteVariable___repr__(DiscreteVariable self) -> std::string"},
	 { "DiscreteVariable___str__", _wrap_DiscreteVariable___str__, METH_O, "DiscreteVariable___str__(DiscreteVariable self) -> std::string"},
	 { "DiscreteVariable_toLabelizedVar", _wrap_DiscreteVariable_toLabelizedVar, METH_O, "\n"
		"DiscreteVariable_toLabelizedVar(DiscreteVariable self) -> LabelizedVariable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.LabelizedVariable\n"
		"	the labelized variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.RuntimeError\n"
		"	If the variable is not a LabelizedVariable\n"
		"\n"
		""},
	 { "DiscreteVariable_toRangeVar", _wrap_DiscreteVariable_toRangeVar, METH_O, "\n"
		"DiscreteVariable_toRangeVar(DiscreteVariable self) -> RangeVariable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.RangeVariable\n"
		"	the range variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.RuntimeError\n"
		"	If the variable is not a RangeVariable\n"
		"\n"
		""},
	 { "DiscreteVariable_toDiscretizedVar", _wrap_DiscreteVariable_toDiscretizedVar, METH_O, "\n"
		"DiscreteVariable_toDiscretizedVar(DiscreteVariable self) -> DiscretizedVariable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DiscretizedVariable\n"
		"	the discretized variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.RuntimeError \n"
		"	If the variable is not a DiscretizedVariable\n"
		"\n"
		""},
	 { "DiscreteVariable_swigregister", DiscreteVariable_swigregister, METH_VARARGS, NULL},
	 { "new_LabelizedVariable", _wrap_new_LabelizedVariable, METH_VARARGS, "\n"
		"LabelizedVariable(std::string const & aName, std::string const & aDesc=\"\", gum::Size const nbrLabel=2)\n"
		"LabelizedVariable(std::string const & aName, std::string const & aDesc, Vector_string labels)\n"
		"new_LabelizedVariable(LabelizedVariable aLDRV) -> LabelizedVariable\n"
		""},
	 { "delete_LabelizedVariable", _wrap_delete_LabelizedVariable, METH_O, "delete_LabelizedVariable(LabelizedVariable self)"},
	 { "LabelizedVariable_clone", _wrap_LabelizedVariable_clone, METH_O, "\n"
		"LabelizedVariable_clone(LabelizedVariable self) -> LabelizedVariable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.LabelizedVariable\n"
		"	a copy of the LabelizedVariable\n"
		"\n"
		""},
	 { "LabelizedVariable_index", _wrap_LabelizedVariable_index, METH_VARARGS, "\n"
		"LabelizedVariable_index(LabelizedVariable self, std::string const & label) -> gum::Idx\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"label : str\n"
		"	a label\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the indice of the label\n"
		"\n"
		""},
	 { "LabelizedVariable_isLabel", _wrap_LabelizedVariable_isLabel, METH_VARARGS, "\n"
		"LabelizedVariable_isLabel(LabelizedVariable self, std::string const & aLabel) -> bool\n"
		"\n"
		"Indicates whether the variable already has the label passed in argument\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"aLabel : str\n"
		"	the label to be tested\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the label already exists\n"
		"\n"
		""},
	 { "LabelizedVariable_addLabel", _wrap_LabelizedVariable_addLabel, METH_VARARGS, "LabelizedVariable_addLabel(LabelizedVariable self, std::string const & aLabel) -> LabelizedVariable"},
	 { "LabelizedVariable_changeLabel", _wrap_LabelizedVariable_changeLabel, METH_VARARGS, "\n"
		"LabelizedVariable_changeLabel(LabelizedVariable self, gum::Idx pos, std::string const & aLabel)\n"
		"\n"
		"Change the label at the specified index\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pos : int\n"
		"	the index of the label to be changed\n"
		"aLabel : str\n"
		"	the label to be added to the labelized variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.DuplicatedElement\n"
		"  If the variable already contains the new label\n"
		"gum.OutOfBounds\n"
		"  If the index is greater than the size of the variable\n"
		"\n"
		""},
	 { "LabelizedVariable_eraseLabels", _wrap_LabelizedVariable_eraseLabels, METH_O, "\n"
		"LabelizedVariable_eraseLabels(LabelizedVariable self)\n"
		"\n"
		"Erase all the labels from the variable.\n"
		"\n"
		""},
	 { "LabelizedVariable_label", _wrap_LabelizedVariable_label, METH_VARARGS, "\n"
		"LabelizedVariable_label(LabelizedVariable self, gum::Idx i) -> std::string\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : int\n"
		"	the index of the label we wish to return\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the indice-th label\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfBound\n"
		"	If the variable does not contain the label\n"
		"\n"
		""},
	 { "LabelizedVariable_posLabel", _wrap_LabelizedVariable_posLabel, METH_VARARGS, "LabelizedVariable_posLabel(LabelizedVariable self, std::string const & label) -> gum::Idx"},
	 { "LabelizedVariable_numerical", _wrap_LabelizedVariable_numerical, METH_VARARGS, "\n"
		"LabelizedVariable_numerical(LabelizedVariable self, gum::Idx indice) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"indice : int\n"
		"	an index\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the numerical representation of the indice-th value\n"
		"\n"
		""},
	 { "LabelizedVariable_domainSize", _wrap_LabelizedVariable_domainSize, METH_O, "\n"
		"LabelizedVariable_domainSize(LabelizedVariable self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of modalities in the variable domain\n"
		"\n"
		""},
	 { "LabelizedVariable_varType", _wrap_LabelizedVariable_varType, METH_O, "\n"
		"LabelizedVariable_varType(LabelizedVariable self) -> gum::VarType\n"
		"\n"
		"returns the type of variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	the type of the variable, 0: DiscretizedVariable, 1: LabelizedVariable, 2: RangeVariable\n"
		"\n"
		""},
	 { "LabelizedVariable_domain", _wrap_LabelizedVariable_domain, METH_O, "\n"
		"LabelizedVariable_domain(LabelizedVariable self) -> std::string const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    the domain of the variable as a string\n"
		"\n"
		""},
	 { "LabelizedVariable___repr__", _wrap_LabelizedVariable___repr__, METH_O, "LabelizedVariable___repr__(LabelizedVariable self) -> std::string"},
	 { "LabelizedVariable___str__", _wrap_LabelizedVariable___str__, METH_O, "LabelizedVariable___str__(LabelizedVariable self) -> std::string"},
	 { "LabelizedVariable_swigregister", LabelizedVariable_swigregister, METH_VARARGS, NULL},
	 { "LabelizedVariable_swiginit", LabelizedVariable_swiginit, METH_VARARGS, NULL},
	 { "new_RangeVariable", _wrap_new_RangeVariable, METH_VARARGS, "\n"
		"RangeVariable(std::string const & aName, std::string const & aDesc, long minVal=0, long maxVal=1)\n"
		"new_RangeVariable(RangeVariable aDRV) -> RangeVariable\n"
		""},
	 { "delete_RangeVariable", _wrap_delete_RangeVariable, METH_O, "delete_RangeVariable(RangeVariable self)"},
	 { "RangeVariable_clone", _wrap_RangeVariable_clone, METH_O, "\n"
		"RangeVariable_clone(RangeVariable self) -> DiscreteVariable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.RangeVariable\n"
		"	a copy of the RangeVariable\n"
		"\n"
		""},
	 { "RangeVariable_domainSize", _wrap_RangeVariable_domainSize, METH_O, "\n"
		"RangeVariable_domainSize(RangeVariable self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of modalities in the variable domain\n"
		"\n"
		""},
	 { "RangeVariable_varType", _wrap_RangeVariable_varType, METH_O, "\n"
		"RangeVariable_varType(RangeVariable self) -> gum::VarType\n"
		"\n"
		"returns the type of variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	the type of the variable, 0: DiscretizedVariable, 1: LabelizedVariable, 2: RangeVariable\n"
		"\n"
		""},
	 { "RangeVariable_label", _wrap_RangeVariable_label, METH_VARARGS, "\n"
		"RangeVariable_label(RangeVariable self, gum::Idx indice) -> std::string\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"indice : int\n"
		"  the index of the label we wish to return\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"  the indice-th label\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfBound\n"
		"  If the variable does not contain the label\n"
		"\n"
		""},
	 { "RangeVariable_numerical", _wrap_RangeVariable_numerical, METH_VARARGS, "\n"
		"RangeVariable_numerical(RangeVariable self, gum::Idx indice) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"indice : int\n"
		"	an index\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the numerical representation of the indice-th value\n"
		"\n"
		""},
	 { "RangeVariable_minVal", _wrap_RangeVariable_minVal, METH_O, "\n"
		"RangeVariable_minVal(RangeVariable self) -> long\n"
		"\n"
		"Returns\n"
		"-------\n"
		"long :\n"
		"  the lower bound of the variable\n"
		"\n"
		""},
	 { "RangeVariable_setMinVal", _wrap_RangeVariable_setMinVal, METH_VARARGS, "\n"
		"RangeVariable_setMinVal(RangeVariable self, long minVal)\n"
		"\n"
		"Set a new value of the lower bound\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"minVal : long\n"
		"  The new value of the lower bound\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"An error should be raised if the value is higher than the upper bound.\n"
		"\n"
		""},
	 { "RangeVariable_maxVal", _wrap_RangeVariable_maxVal, METH_O, "\n"
		"RangeVariable_maxVal(RangeVariable self) -> long\n"
		"\n"
		"Returns\n"
		"-------\n"
		"long :\n"
		"  the upper bound of the variable.\n"
		"\n"
		""},
	 { "RangeVariable_setMaxVal", _wrap_RangeVariable_setMaxVal, METH_VARARGS, "\n"
		"RangeVariable_setMaxVal(RangeVariable self, long maxVal)\n"
		"\n"
		"Set a new value of the upper bound\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"maxVal : long\n"
		"  The new value of the upper bound\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"An error should be raised if the value is lower than the lower bound.\n"
		"\n"
		""},
	 { "RangeVariable_belongs", _wrap_RangeVariable_belongs, METH_VARARGS, "\n"
		"RangeVariable_belongs(RangeVariable self, long val) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"val : long\n"
		"  the value to be tested\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool:\n"
		"  True if the value in parameters belongs to the variable's interval.\n"
		"\n"
		""},
	 { "RangeVariable_index", _wrap_RangeVariable_index, METH_VARARGS, "\n"
		"RangeVariable_index(RangeVariable self, std::string const & arg2) -> gum::Idx\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arg2 : str\n"
		"  a label\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the indice of the label\n"
		"\n"
		""},
	 { "RangeVariable_domain", _wrap_RangeVariable_domain, METH_O, "\n"
		"RangeVariable_domain(RangeVariable self) -> std::string const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the domain of the variable\n"
		"\n"
		""},
	 { "RangeVariable___repr__", _wrap_RangeVariable___repr__, METH_O, "RangeVariable___repr__(RangeVariable self) -> std::string"},
	 { "RangeVariable___str__", _wrap_RangeVariable___str__, METH_O, "RangeVariable___str__(RangeVariable self) -> std::string"},
	 { "RangeVariable_swigregister", RangeVariable_swigregister, METH_VARARGS, NULL},
	 { "RangeVariable_swiginit", RangeVariable_swiginit, METH_VARARGS, NULL},
	 { "delete_IDiscretizedVariable", _wrap_delete_IDiscretizedVariable, METH_O, "delete_IDiscretizedVariable(IDiscretizedVariable self)"},
	 { "IDiscretizedVariable_clone", _wrap_IDiscretizedVariable_clone, METH_O, "\n"
		"IDiscretizedVariable_clone(IDiscretizedVariable self) -> IDiscretizedVariable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DiscreteVariable\n"
		"	a copy of the DiscreteVariable\n"
		"\n"
		""},
	 { "IDiscretizedVariable_swigregister", IDiscretizedVariable_swigregister, METH_VARARGS, NULL},
	 { "new_Edge", _wrap_new_Edge, METH_VARARGS, "\n"
		"Edge(gum::NodeId aN1, gum::NodeId aN2)\n"
		"new_Edge(Edge src) -> Edge\n"
		""},
	 { "delete_Edge", _wrap_delete_Edge, METH_O, "delete_Edge(Edge self)"},
	 { "Edge_other", _wrap_Edge_other, METH_VARARGS, "\n"
		"Edge_other(Edge self, gum::NodeId id) -> gum::NodeId\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  the nodeId of one of the nodes of the Edge\n"
		"\n"
		"\n"
		"Returns\n"
		"------\n"
		"int\n"
		"  the nodeId of the other node\n"
		"\n"
		""},
	 { "Edge_first", _wrap_Edge_first, METH_O, "\n"
		"Edge_first(Edge self) -> gum::NodeId\n"
		"\n"
		"Returns\n"
		"------\n"
		"int\n"
		"  the nodeId of the first node of the arc (the tail)\n"
		"\n"
		""},
	 { "Edge_second", _wrap_Edge_second, METH_O, "\n"
		"Edge_second(Edge self) -> gum::NodeId\n"
		"\n"
		"Returns\n"
		"------\n"
		"int\n"
		"  the nodeId of the second node of the arc (the head)\n"
		"\n"
		""},
	 { "Edge___eq__", _wrap_Edge___eq__, METH_VARARGS, "Edge___eq__(Edge self, Edge src) -> bool"},
	 { "Edge___ne__", _wrap_Edge___ne__, METH_VARARGS, "Edge___ne__(Edge self, Edge src) -> bool"},
	 { "Edge_swigregister", Edge_swigregister, METH_VARARGS, NULL},
	 { "Edge_swiginit", Edge_swiginit, METH_VARARGS, NULL},
	 { "new_Arc", _wrap_new_Arc, METH_VARARGS, "\n"
		"Arc(gum::NodeId tail, gum::NodeId head)\n"
		"new_Arc(Arc src) -> Arc\n"
		""},
	 { "delete_Arc", _wrap_delete_Arc, METH_O, "delete_Arc(Arc self)"},
	 { "Arc_tail", _wrap_Arc_tail, METH_O, "\n"
		"Arc_tail(Arc self) -> gum::NodeId\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the id of the tail node\n"
		"\n"
		""},
	 { "Arc_head", _wrap_Arc_head, METH_O, "\n"
		"Arc_head(Arc self) -> gum::NodeId\n"
		"\n"
		"Returns\n"
		"------\n"
		"int\n"
		"  the id of the head node\n"
		"\n"
		""},
	 { "Arc_other", _wrap_Arc_other, METH_VARARGS, "\n"
		"Arc_other(Arc self, gum::NodeId id) -> gum::NodeId\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  the nodeId of the head or the tail\n"
		"\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the nodeId of the other node\n"
		"\n"
		""},
	 { "Arc_first", _wrap_Arc_first, METH_O, "\n"
		"Arc_first(Arc self) -> gum::NodeId\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the nodeId of the first node of the arc (the tail)\n"
		"\n"
		""},
	 { "Arc_second", _wrap_Arc_second, METH_O, "\n"
		"Arc_second(Arc self) -> gum::NodeId\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the nodeId of the second node of the arc (the head)\n"
		"\n"
		""},
	 { "Arc___eq__", _wrap_Arc___eq__, METH_VARARGS, "Arc___eq__(Arc self, Arc src) -> bool"},
	 { "Arc___ne__", _wrap_Arc___ne__, METH_VARARGS, "Arc___ne__(Arc self, Arc src) -> bool"},
	 { "Arc_swigregister", Arc_swigregister, METH_VARARGS, NULL},
	 { "Arc_swiginit", Arc_swiginit, METH_VARARGS, NULL},
	 { "new_UndiGraph", _wrap_new_UndiGraph, METH_VARARGS, "\n"
		"UndiGraph(gum::Size nodes_size=HashTableConst::default_size, bool nodes_resize_policy=True, gum::Size edges_size=HashTableConst::default_size, bool edges_resize_policy=True)\n"
		"new_UndiGraph(UndiGraph g) -> UndiGraph\n"
		""},
	 { "delete_UndiGraph", _wrap_delete_UndiGraph, METH_O, "delete_UndiGraph(UndiGraph self)"},
	 { "UndiGraph___eq__", _wrap_UndiGraph___eq__, METH_VARARGS, "UndiGraph___eq__(UndiGraph self, UndiGraph g) -> bool"},
	 { "UndiGraph___ne__", _wrap_UndiGraph___ne__, METH_VARARGS, "UndiGraph___ne__(UndiGraph self, UndiGraph g) -> bool"},
	 { "UndiGraph_eraseNode", _wrap_UndiGraph_eraseNode, METH_VARARGS, "\n"
		"UndiGraph_eraseNode(UndiGraph self, gum::NodeId const id)\n"
		"\n"
		"Erase the node and all the adjacent edges.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  the id of the node\n"
		"\n"
		""},
	 { "UndiGraph_clear", _wrap_UndiGraph_clear, METH_O, "\n"
		"UndiGraph_clear(UndiGraph self)\n"
		"\n"
		"Remove all the nodes and edges from the graph.\n"
		"\n"
		""},
	 { "UndiGraph_toDot", _wrap_UndiGraph_toDot, METH_O, "\n"
		"UndiGraph_toDot(UndiGraph self) -> std::string const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a friendly display of the graph in DOT format\n"
		"\n"
		""},
	 { "UndiGraph_hasUndirectedCycle", _wrap_UndiGraph_hasUndirectedCycle, METH_O, "\n"
		"UndiGraph_hasUndirectedCycle(UndiGraph self) -> bool\n"
		"\n"
		"Checks whether the graph contains cycles.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the graph contains a cycle\n"
		"\n"
		""},
	 { "UndiGraph_partialUndiGraph", _wrap_UndiGraph_partialUndiGraph, METH_VARARGS, "\n"
		"UndiGraph_partialUndiGraph(UndiGraph self, gum::NodeSet nodesSet) -> UndiGraph\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"nodesSet : Set\n"
		"    The set of nodes composing the partial graph\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.UndiGraph\n"
		"    The partial graph formed by the nodes given in parameter\n"
		"\n"
		""},
	 { "UndiGraph___repr__", _wrap_UndiGraph___repr__, METH_O, "UndiGraph___repr__(UndiGraph self) -> std::string"},
	 { "UndiGraph___str__", _wrap_UndiGraph___str__, METH_O, "UndiGraph___str__(UndiGraph self) -> std::string"},
	 { "UndiGraph_nodes", _wrap_UndiGraph_nodes, METH_O, "\n"
		"UndiGraph_nodes(UndiGraph self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of ids\n"
		"\n"
		""},
	 { "UndiGraph_addNodes", _wrap_UndiGraph_addNodes, METH_VARARGS, "\n"
		"UndiGraph_addNodes(UndiGraph self, gum::Size n) -> PyObject *\n"
		"\n"
		"Add n nodes.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int\n"
		"  the number of nodes to add.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set of int\n"
		"  the new ids\n"
		"\n"
		""},
	 { "UndiGraph_edges", _wrap_UndiGraph_edges, METH_O, "\n"
		"UndiGraph_edges(UndiGraph self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"  the list of the edges\n"
		"\n"
		""},
	 { "UndiGraph_neighbours", _wrap_UndiGraph_neighbours, METH_VARARGS, "\n"
		"UndiGraph_neighbours(UndiGraph self, gum::NodeId id) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the id of the checked node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"    The set of edges adjacent to the given node\n"
		"\n"
		""},
	 { "UndiGraph_addNode", _wrap_UndiGraph_addNode, METH_O, "\n"
		"UndiGraph_addNode(UndiGraph self) -> gum::NodeId\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the new NodeId\n"
		"\n"
		""},
	 { "UndiGraph_addNodeWithId", _wrap_UndiGraph_addNodeWithId, METH_VARARGS, "\n"
		"UndiGraph_addNodeWithId(UndiGraph self, gum::NodeId const id)\n"
		"\n"
		"Add a node by choosing a new NodeId.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  The id of the new node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.DuplicateElement\n"
		"  If the given id is already used\n"
		"\n"
		""},
	 { "UndiGraph_existsNode", _wrap_UndiGraph_existsNode, METH_VARARGS, "\n"
		"UndiGraph_existsNode(UndiGraph self, gum::NodeId const id) -> bool\n"
		"\n"
		"Check if a node with a certain id exists in the graph.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the checked id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the node exists\n"
		"\n"
		""},
	 { "UndiGraph_size", _wrap_UndiGraph_size, METH_O, "\n"
		"UndiGraph_size(UndiGraph self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of nodes in the graph\n"
		"\n"
		""},
	 { "UndiGraph_empty", _wrap_UndiGraph_empty, METH_O, "\n"
		"UndiGraph_empty(UndiGraph self) -> bool\n"
		"\n"
		"Check if the graph is empty.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the graph is empty\n"
		"\n"
		""},
	 { "UndiGraph_addEdge", _wrap_UndiGraph_addEdge, METH_VARARGS, "\n"
		"UndiGraph_addEdge(UndiGraph self, gum::NodeId const n1, gum::NodeId const n2)\n"
		"\n"
		"Insert a new edge into the graph.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n1 : int\n"
		"  the id of one node of the new inserted edge\n"
		"n2 : int\n"
		"  the id of the other node of the new inserted edge\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidNode\n"
		"  If n1 or n2 does not belong to the graph nodes.\n"
		"\n"
		""},
	 { "UndiGraph_eraseEdge", _wrap_UndiGraph_eraseEdge, METH_VARARGS, "\n"
		"UndiGraph_eraseEdge(UndiGraph self, gum::NodeId const n1, gum::NodeId const n2)\n"
		"\n"
		"Erase the edge between n1 and n2.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n1 : int\n"
		"  the id of the tail node\n"
		"n2 : int\n"
		"  the id of the head node\n"
		"\n"
		""},
	 { "UndiGraph_existsEdge", _wrap_UndiGraph_existsEdge, METH_VARARGS, "\n"
		"UndiGraph_existsEdge(UndiGraph self, gum::NodeId const n1, gum::NodeId const n2) -> bool\n"
		"\n"
		"Check if an edge exists bewteen n1 and n2.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n1 : int\n"
		"  the id of one extremity of the edge\n"
		"n2 : int\n"
		"  the id of the other extremity if tge edge\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the arc exists\n"
		"\n"
		""},
	 { "UndiGraph_sizeEdges", _wrap_UndiGraph_sizeEdges, METH_O, "\n"
		"UndiGraph_sizeEdges(UndiGraph self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of edges in the graph\n"
		"\n"
		""},
	 { "UndiGraph_emptyEdges", _wrap_UndiGraph_emptyEdges, METH_O, "\n"
		"UndiGraph_emptyEdges(UndiGraph self) -> bool\n"
		"\n"
		"Check if the graph doesn't contains edges.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the graph doesn't contains edges\n"
		"\n"
		""},
	 { "UndiGraph_eraseNeighbours", _wrap_UndiGraph_eraseNeighbours, METH_VARARGS, "\n"
		"UndiGraph_eraseNeighbours(UndiGraph self, gum::NodeId const n)\n"
		"\n"
		"Erase all the edges adjacent to a given node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int\n"
		"  the id of the node\n"
		"\n"
		""},
	 { "UndiGraph_swigregister", UndiGraph_swigregister, METH_VARARGS, NULL},
	 { "UndiGraph_swiginit", UndiGraph_swiginit, METH_VARARGS, NULL},
	 { "new_DiGraph", _wrap_new_DiGraph, METH_VARARGS, "\n"
		"DiGraph(gum::Size nodes_size=HashTableConst::default_size, bool nodes_resize_policy=True, gum::Size arcs_size=HashTableConst::default_size, bool arcs_resize_policy=True)\n"
		"new_DiGraph(DiGraph g) -> DiGraph\n"
		""},
	 { "delete_DiGraph", _wrap_delete_DiGraph, METH_O, "delete_DiGraph(DiGraph self)"},
	 { "DiGraph___eq__", _wrap_DiGraph___eq__, METH_VARARGS, "DiGraph___eq__(DiGraph self, DiGraph g) -> bool"},
	 { "DiGraph___ne__", _wrap_DiGraph___ne__, METH_VARARGS, "DiGraph___ne__(DiGraph self, DiGraph g) -> bool"},
	 { "DiGraph_eraseNode", _wrap_DiGraph_eraseNode, METH_VARARGS, "\n"
		"DiGraph_eraseNode(DiGraph self, gum::NodeId const id)\n"
		"\n"
		"Erase the node and all the related arcs.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	the id of the node\n"
		"\n"
		""},
	 { "DiGraph_clear", _wrap_DiGraph_clear, METH_O, "\n"
		"DiGraph_clear(DiGraph self)\n"
		"\n"
		"Remove all the nodes and arcs from the graph.\n"
		"\n"
		""},
	 { "DiGraph_toDot", _wrap_DiGraph_toDot, METH_O, "\n"
		"DiGraph_toDot(DiGraph self) -> std::string const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a friendly display of the graph in DOT format \n"
		"\n"
		""},
	 { "DiGraph_topologicalOrder", _wrap_DiGraph_topologicalOrder, METH_VARARGS, "\n"
		"DiGraph_topologicalOrder(DiGraph self, bool clear=True) -> gum::Sequence< gum::NodeId > const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"    the list of the nodes Ids in a topological order\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidDirectedCycle\n"
		"  If this graph contains cycles\n"
		"\n"
		""},
	 { "DiGraph___repr__", _wrap_DiGraph___repr__, METH_O, "DiGraph___repr__(DiGraph self) -> std::string"},
	 { "DiGraph___str__", _wrap_DiGraph___str__, METH_O, "DiGraph___str__(DiGraph self) -> std::string"},
	 { "DiGraph_nodes", _wrap_DiGraph_nodes, METH_O, "\n"
		"DiGraph_nodes(DiGraph self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of ids\n"
		"\n"
		""},
	 { "DiGraph_addNodes", _wrap_DiGraph_addNodes, METH_VARARGS, "\n"
		"DiGraph_addNodes(DiGraph self, gum::Size n) -> PyObject *\n"
		"\n"
		"Add n nodes.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int\n"
		"  the number of nodes to add.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set of int\n"
		"  the new ids\n"
		"\n"
		""},
	 { "DiGraph_arcs", _wrap_DiGraph_arcs, METH_O, "\n"
		"DiGraph_arcs(DiGraph self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"	the list of the arcs\n"
		"\n"
		""},
	 { "DiGraph_parents", _wrap_DiGraph_parents, METH_VARARGS, "\n"
		"DiGraph_parents(DiGraph self, gum::NodeId id) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id :\n"
		"	The id of the child node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"    the set of the parents ids.\n"
		"\n"
		""},
	 { "DiGraph_children", _wrap_DiGraph_children, METH_VARARGS, "\n"
		"DiGraph_children(DiGraph self, gum::NodeId id) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  the id of the parent\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"	the set of all the children\n"
		"\n"
		""},
	 { "DiGraph_addNode", _wrap_DiGraph_addNode, METH_O, "\n"
		"DiGraph_addNode(DiGraph self) -> gum::NodeId\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the new NodeId\n"
		"\n"
		""},
	 { "DiGraph_addNodeWithId", _wrap_DiGraph_addNodeWithId, METH_VARARGS, "\n"
		"DiGraph_addNodeWithId(DiGraph self, gum::NodeId const id)\n"
		"\n"
		"Add a node by choosing a new NodeId.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  The id of the new node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.DuplicateElement\n"
		"  If the given id is already used\n"
		"\n"
		""},
	 { "DiGraph_existsNode", _wrap_DiGraph_existsNode, METH_VARARGS, "\n"
		"DiGraph_existsNode(DiGraph self, gum::NodeId const id) -> bool\n"
		"\n"
		"Check if a node with a certain id exists in the graph.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the checked id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the node exists\n"
		"\n"
		""},
	 { "DiGraph_size", _wrap_DiGraph_size, METH_O, "\n"
		"DiGraph_size(DiGraph self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of nodes in the graph\n"
		"\n"
		""},
	 { "DiGraph_empty", _wrap_DiGraph_empty, METH_O, "\n"
		"DiGraph_empty(DiGraph self) -> bool\n"
		"\n"
		"Check if the graph is empty.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the graph is empty\n"
		"\n"
		""},
	 { "DiGraph_addArc", _wrap_DiGraph_addArc, METH_VARARGS, "\n"
		"DiGraph_addArc(DiGraph self, gum::NodeId const tail, gum::NodeId const head)\n"
		"DiGraph_addArc(DiGraph self, gum::NodeId const n1, gum::NodeId const n2)\n"
		"\n"
		"Add an arc from tail to head.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tail : int\n"
		"  the id of the tail node\n"
		"head : int\n"
		"  the id of the head node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidNode\n"
		"  If head or tail does not belong to the graph nodes.\n"
		"\n"
		""},
	 { "DiGraph_eraseArc", _wrap_DiGraph_eraseArc, METH_VARARGS, "\n"
		"DiGraph_eraseArc(DiGraph self, gum::NodeId const n1, gum::NodeId const n2)\n"
		"\n"
		"Erase the arc between n1 and n2.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n1 : int\n"
		"	the id of the tail node\n"
		"n2 : int\n"
		"	the id of the head node\n"
		"\n"
		""},
	 { "DiGraph_existsArc", _wrap_DiGraph_existsArc, METH_VARARGS, "\n"
		"DiGraph_existsArc(DiGraph self, gum::NodeId const n1, gum::NodeId const n2) -> bool\n"
		"\n"
		"Check if an arc exists bewteen n1 and n2.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n1 : int\n"
		"	the id of the tail node\n"
		"n2 : int\n"
		"	the id of the head node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the arc exists\n"
		"\n"
		""},
	 { "DiGraph_eraseParents", _wrap_DiGraph_eraseParents, METH_VARARGS, "\n"
		"DiGraph_eraseParents(DiGraph self, gum::NodeId const n)\n"
		"\n"
		"Erase the arcs coming to the node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int\n"
		"	the id of the child node\n"
		"\n"
		""},
	 { "DiGraph_eraseChildren", _wrap_DiGraph_eraseChildren, METH_VARARGS, "\n"
		"DiGraph_eraseChildren(DiGraph self, gum::NodeId const n)\n"
		"\n"
		"Erase the arcs heading through the node's children.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int\n"
		"	the id of the parent node\n"
		"\n"
		""},
	 { "DiGraph_sizeArcs", _wrap_DiGraph_sizeArcs, METH_O, "\n"
		"DiGraph_sizeArcs(DiGraph self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of arcs in the graph\n"
		"\n"
		""},
	 { "DiGraph_emptyArcs", _wrap_DiGraph_emptyArcs, METH_O, "\n"
		"DiGraph_emptyArcs(DiGraph self) -> bool\n"
		"\n"
		"Check if the graph doesn't contains arcs.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the graph doesn't contains arcs\n"
		"\n"
		""},
	 { "DiGraph_swigregister", DiGraph_swigregister, METH_VARARGS, NULL},
	 { "DiGraph_swiginit", DiGraph_swiginit, METH_VARARGS, NULL},
	 { "new_DAG", _wrap_new_DAG, METH_VARARGS, "\n"
		"DAG(gum::Size nodes_size=HashTableConst::default_size, bool nodes_resize_policy=True, gum::Size arcs_size=HashTableConst::default_size, bool arcs_resize_policy=True)\n"
		"new_DAG(DAG g) -> DAG\n"
		""},
	 { "delete_DAG", _wrap_delete_DAG, METH_O, "delete_DAG(DAG self)"},
	 { "DAG_moralGraph", _wrap_DAG_moralGraph, METH_O, "DAG_moralGraph(DAG self) -> UndiGraph"},
	 { "DAG_addNodes", _wrap_DAG_addNodes, METH_VARARGS, "DAG_addNodes(DAG self, gum::Size n) -> PyObject *"},
	 { "DAG_addArc", _wrap_DAG_addArc, METH_VARARGS, "\n"
		"DAG_addArc(DAG self, gum::NodeId const tail, gum::NodeId const head)\n"
		"DAG_addArc(DAG self, gum::NodeId const n1, gum::NodeId const n2)\n"
		"\n"
		"Add an arc from tail to head.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tail : int\n"
		"  the id of the tail node\n"
		"head : int\n"
		"  the id of the head node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidDirectedCircle\n"
		"	If any (directed) cycle is created by this arc\n"
		"gum.InvalidNode\n"
		"	If head or tail does not belong to the graph nodes\n"
		"\n"
		""},
	 { "DAG_swigregister", DAG_swigregister, METH_VARARGS, NULL},
	 { "DAG_swiginit", DAG_swiginit, METH_VARARGS, NULL},
	 { "new_MixedGraph", _wrap_new_MixedGraph, METH_VARARGS, "\n"
		"MixedGraph(gum::Size nodes_size=HashTableConst::default_size, bool nodes_resize_policy=True, gum::Size arcs_size=HashTableConst::default_size, bool arcs_resize_policy=True, gum::Size edges_size=HashTableConst::default_size, bool edges_resize_policy=True)\n"
		"new_MixedGraph(MixedGraph g) -> MixedGraph\n"
		""},
	 { "delete_MixedGraph", _wrap_delete_MixedGraph, METH_O, "delete_MixedGraph(MixedGraph self)"},
	 { "MixedGraph___eq__", _wrap_MixedGraph___eq__, METH_VARARGS, "MixedGraph___eq__(MixedGraph self, MixedGraph g) -> bool"},
	 { "MixedGraph___ne__", _wrap_MixedGraph___ne__, METH_VARARGS, "MixedGraph___ne__(MixedGraph self, MixedGraph g) -> bool"},
	 { "MixedGraph_eraseNode", _wrap_MixedGraph_eraseNode, METH_VARARGS, "\n"
		"MixedGraph_eraseNode(MixedGraph self, gum::NodeId const id)\n"
		"\n"
		"Erase the node and all the adjacent edges.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  the id of the node\n"
		"\n"
		""},
	 { "MixedGraph_clear", _wrap_MixedGraph_clear, METH_O, "\n"
		"MixedGraph_clear(MixedGraph self)\n"
		"\n"
		"Remove all the nodes and edges from the graph.\n"
		"\n"
		""},
	 { "MixedGraph_mixedOrientedPath", _wrap_MixedGraph_mixedOrientedPath, METH_VARARGS, "\n"
		"MixedGraph_mixedOrientedPath(MixedGraph self, gum::NodeId const node1, gum::NodeId const node2) -> std::vector< gum::NodeId,std::allocator< gum::NodeId > > const\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node1 : int\n"
		"	the id form which the path begins\n"
		"node2 : int\n"
		"	the id to witch the path ends\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"	 a path from node1 to node2, using edges and/or arcs (following the direction of the arcs)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"	If no path can be found between the two nodes\n"
		"\n"
		""},
	 { "MixedGraph_mixedUnorientedPath", _wrap_MixedGraph_mixedUnorientedPath, METH_VARARGS, "\n"
		"MixedGraph_mixedUnorientedPath(MixedGraph self, gum::NodeId const node1, gum::NodeId const node2) -> std::vector< gum::NodeId,std::allocator< gum::NodeId > > const\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node1 : int\n"
		"	the id from which the path begins\n"
		"node2 : int\n"
		"	the id to which the path ends\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"	 a path from node1 to node2, using edges and/or arcs (not necessarily following the direction of the arcs)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"	If no path can be found between the two nodes\n"
		"\n"
		""},
	 { "MixedGraph_toDot", _wrap_MixedGraph_toDot, METH_O, "\n"
		"MixedGraph_toDot(MixedGraph self) -> std::string const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a friendly display of the graph in DOT format\n"
		"\n"
		""},
	 { "MixedGraph___repr__", _wrap_MixedGraph___repr__, METH_O, "MixedGraph___repr__(MixedGraph self) -> std::string"},
	 { "MixedGraph___str__", _wrap_MixedGraph___str__, METH_O, "MixedGraph___str__(MixedGraph self) -> std::string"},
	 { "MixedGraph_swigregister", MixedGraph_swigregister, METH_VARARGS, NULL},
	 { "MixedGraph_swiginit", MixedGraph_swiginit, METH_VARARGS, NULL},
	 { "new_CliqueGraph", _wrap_new_CliqueGraph, METH_VARARGS, "\n"
		"CliqueGraph(gum::Size nodes_size=HashTableConst::default_size, bool nodes_resize_policy=True, gum::Size edges_size=HashTableConst::default_size, bool edges_resize_policy=True)\n"
		"new_CliqueGraph(CliqueGraph _from) -> CliqueGraph\n"
		""},
	 { "delete_CliqueGraph", _wrap_delete_CliqueGraph, METH_O, "delete_CliqueGraph(CliqueGraph self)"},
	 { "CliqueGraph_addEdge", _wrap_CliqueGraph_addEdge, METH_VARARGS, "\n"
		"CliqueGraph_addEdge(CliqueGraph self, gum::NodeId const first, gum::NodeId const second)\n"
		"\n"
		"Insert a new edge into the graph.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n1 : int\n"
		"  the id of one node of the new inserted edge\n"
		"n2 : int\n"
		"  the id of the other node of the new inserted edge\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidNode\n"
		"  If n1 or n2 does not belong to the graph nodes.\n"
		"\n"
		""},
	 { "CliqueGraph_eraseEdge", _wrap_CliqueGraph_eraseEdge, METH_VARARGS, "\n"
		"CliqueGraph_eraseEdge(CliqueGraph self, Edge edge)\n"
		"\n"
		"Erase the edge between n1 and n2.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n1 : int\n"
		"  the id of the tail node\n"
		"n2 : int\n"
		"  the id of the head node\n"
		"\n"
		""},
	 { "CliqueGraph_clearEdges", _wrap_CliqueGraph_clearEdges, METH_O, "\n"
		"CliqueGraph_clearEdges(CliqueGraph self)\n"
		"\n"
		"Remove all edges and their separators \n"
		"\n"
		""},
	 { "CliqueGraph_addNode", _wrap_CliqueGraph_addNode, METH_VARARGS, "\n"
		"CliqueGraph_addNode(CliqueGraph self, gum::NodeSet const & clique) -> gum::NodeId\n"
		"CliqueGraph_addNode(CliqueGraph self) -> gum::NodeId\n"
		"CliqueGraph_addNode(CliqueGraph self, gum::NodeId const id, gum::NodeSet const & clique)\n"
		"CliqueGraph_addNode(CliqueGraph self, gum::NodeId const id)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the new NodeId\n"
		"\n"
		""},
	 { "CliqueGraph_eraseNode", _wrap_CliqueGraph_eraseNode, METH_VARARGS, "\n"
		"CliqueGraph_eraseNode(CliqueGraph self, gum::NodeId const node)\n"
		"\n"
		"Erase the node and all the adjacent edges.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  the id of the node\n"
		"\n"
		""},
	 { "CliqueGraph_clear", _wrap_CliqueGraph_clear, METH_O, "\n"
		"CliqueGraph_clear(CliqueGraph self)\n"
		"\n"
		"Remove all the nodes and edges from the graph.\n"
		"\n"
		""},
	 { "CliqueGraph_container", _wrap_CliqueGraph_container, METH_VARARGS, "\n"
		"CliqueGraph_container(CliqueGraph self, gum::NodeId const idNode) -> gum::NodeId\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"idNode : int\n"
		"  the id of the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the id of a clique containing the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"  If no clique contains idNode  \n"
		"\n"
		""},
	 { "CliqueGraph_setClique", _wrap_CliqueGraph_setClique, METH_VARARGS, "\n"
		"CliqueGraph_setClique(CliqueGraph self, gum::NodeId const idClique, gum::NodeSet const & new_clique)\n"
		"\n"
		"changes the set of nodes included into a given clique\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"idClique : int\n"
		"  the id of the clique\n"
		"new_clique : Set\n"
		"  the new set of nodes to be included in the clique\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"  If idClique is not a clique of the graph\n"
		"\n"
		""},
	 { "CliqueGraph_addToClique", _wrap_CliqueGraph_addToClique, METH_VARARGS, "\n"
		"CliqueGraph_addToClique(CliqueGraph self, gum::NodeId const clique_id, gum::NodeId const node_id)\n"
		"\n"
		"Change the set of nodes included into a given clique and returns the new set \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"clique_id : int\n"
		"  the id of the clique\n"
		"node_id : int\n"
		"  the id of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"  If clique_id does not exist\n"
		"gum.DuplicateElement\n"
		"  If clique_id set already contains the ndoe\n"
		"\n"
		""},
	 { "CliqueGraph_eraseFromClique", _wrap_CliqueGraph_eraseFromClique, METH_VARARGS, "\n"
		"CliqueGraph_eraseFromClique(CliqueGraph self, gum::NodeId const clique_id, gum::NodeId const node_id)\n"
		"\n"
		"Remove a node from a clique\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"clique_id : int\n"
		"  the id of the clique\n"
		"node_id : int\n"
		"  the id of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"  If clique_id does not exist\n"
		"\n"
		""},
	 { "CliqueGraph_containerPath", _wrap_CliqueGraph_containerPath, METH_VARARGS, "\n"
		"CliqueGraph_containerPath(CliqueGraph self, gum::NodeId const node1, gum::NodeId const node2) -> std::vector< gum::NodeId,std::allocator< gum::NodeId > >\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node1 : int\n"
		"  the id of one node\n"
		"node2 : int\n"
		"  the id of the other node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"  a path from a clique containing node1 to a clique containing node2\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound \n"
		"  If such path cannot be found\n"
		"\n"
		""},
	 { "CliqueGraph_hasRunningIntersection", _wrap_CliqueGraph_hasRunningIntersection, METH_O, "\n"
		"CliqueGraph_hasRunningIntersection(CliqueGraph self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if the running intersection property holds \n"
		"\n"
		""},
	 { "CliqueGraph_isJoinTree", _wrap_CliqueGraph_isJoinTree, METH_O, "\n"
		"CliqueGraph_isJoinTree(CliqueGraph self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if the graph is a join tree \n"
		"\n"
		""},
	 { "CliqueGraph_toDot", _wrap_CliqueGraph_toDot, METH_O, "\n"
		"CliqueGraph_toDot(CliqueGraph self) -> std::string const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a friendly display of the graph in DOT format\n"
		"\n"
		""},
	 { "CliqueGraph___ne__", _wrap_CliqueGraph___ne__, METH_VARARGS, "CliqueGraph___ne__(CliqueGraph self, CliqueGraph _from) -> bool"},
	 { "CliqueGraph___eq__", _wrap_CliqueGraph___eq__, METH_VARARGS, "CliqueGraph___eq__(CliqueGraph self, CliqueGraph _from) -> bool"},
	 { "CliqueGraph_clique", _wrap_CliqueGraph_clique, METH_VARARGS, "\n"
		"CliqueGraph_clique(CliqueGraph self, gum::NodeId const clique) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"idClique : int\n"
		"  the id of the clique\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"  The set of nodes included in the clique\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"  If the clique does not belong to the clique graph\n"
		"\n"
		""},
	 { "CliqueGraph_separator", _wrap_CliqueGraph_separator, METH_VARARGS, "\n"
		"CliqueGraph_separator(CliqueGraph self, gum::NodeId const cliq1, gum::NodeId const cliq2) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"edge : pyAgrum.Edge\n"
		"  the edge to be checked\n"
		"clique1 : int \n"
		"  one extremity of the edge\n"
		"clique : int \n"
		"  the other extremity of the edge\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"  the separator included in a given edge\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"  If the edge does not belong to the clique graph\n"
		"\n"
		""},
	 { "CliqueGraph_swigregister", CliqueGraph_swigregister, METH_VARARGS, NULL},
	 { "CliqueGraph_swiginit", CliqueGraph_swiginit, METH_VARARGS, NULL},
	 { "new_Instantiation", _wrap_new_Instantiation, METH_VARARGS, "\n"
		"Instantiation()\n"
		"Instantiation(Instantiation aI, bool const notifyMaster=True)\n"
		"Instantiation(MultiDimAdressable aMD)\n"
		"Instantiation(MultiDimAdressable aMD)\n"
		"Instantiation(MultiDimAdressable aMD)\n"
		"new_Instantiation(MultiDimAdressable aMD) -> Instantiation\n"
		""},
	 { "delete_Instantiation", _wrap_delete_Instantiation, METH_O, "delete_Instantiation(Instantiation self)"},
	 { "Instantiation_nbrDim", _wrap_Instantiation_nbrDim, METH_O, "\n"
		"Instantiation_nbrDim(Instantiation self) -> gum::Idx\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    The number of variables in the Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_add", _wrap_Instantiation_add, METH_VARARGS, "\n"
		"Instantiation_add(Instantiation self, DiscreteVariable v)\n"
		"\n"
		"Adds a new variable in the Instantiation.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		"  The new variable added to the Instantiation\n"
		"\n"
		"Raises\n"
		"------\n"
		"DuplicateElement\n"
		"  If the variable is already in this Instantiation\n"
		"\n"
		"\n"
		""},
	 { "Instantiation_erase", _wrap_Instantiation_erase, METH_VARARGS, "\n"
		"Instantiation_erase(Instantiation self, DiscreteVariable v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		"  The variable to be removed from this Instantiation.\n"
		"\n"
		"Raises\n"
		"------\n"
		"NotFound\n"
		"  If v does not belong to this Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_clear", _wrap_Instantiation_clear, METH_O, "\n"
		"Instantiation_clear(Instantiation self)\n"
		"\n"
		"Erase all variables from an Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_domainSize", _wrap_Instantiation_domainSize, METH_O, "\n"
		"Instantiation_domainSize(Instantiation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    The product of the variable's domain size in the Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_pos", _wrap_Instantiation_pos, METH_VARARGS, "\n"
		"Instantiation_pos(Instantiation self, DiscreteVariable v) -> gum::Idx\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"   the position of the variable v.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		"    the variable for which its position is return.\n"
		"\n"
		"Raises\n"
		"------\n"
		"NotFound\n"
		"  If v does not belong to the instantiation.\n"
		"\n"
		""},
	 { "Instantiation_val", _wrap_Instantiation_val, METH_VARARGS, "\n"
		"Instantiation_val(Instantiation self, gum::Idx i) -> gum::Idx\n"
		"Instantiation_val(Instantiation self, DiscreteVariable var) -> gum::Idx\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : int\n"
		"	The index of the variable.\n"
		"var : pyAgrum.DiscreteVariable\n"
		"	The variable the value of which we wish to know\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the current value of the variable.\n"
		"\n"
		"Raises\n"
		"------\n"
		"NotFound\n"
		"  If the element cannot be found.\n"
		"\n"
		""},
	 { "Instantiation_variable", _wrap_Instantiation_variable, METH_VARARGS, "\n"
		"Instantiation_variable(Instantiation self, gum::Idx i) -> DiscreteVariable\n"
		"Instantiation_variable(Instantiation self, std::string const & name) -> DiscreteVariable\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : int\n"
		"  The index of the variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DiscreteVariable\n"
		"  the variable at position i in the tuple.\n"
		"\n"
		"Raises\n"
		"------\n"
		"NotFound\n"
		"  If the element cannot be found.\n"
		"\n"
		""},
	 { "Instantiation_chgVal", _wrap_Instantiation_chgVal, METH_VARARGS, "\n"
		"Instantiation_chgVal(Instantiation self, DiscreteVariable v, gum::Idx newval) -> Instantiation\n"
		"Instantiation_chgVal(Instantiation self, DiscreteVariable v, gum::Idx newval) -> Instantiation\n"
		"Instantiation_chgVal(Instantiation self, gum::Idx varPos, gum::Idx newval) -> Instantiation\n"
		"Instantiation_chgVal(Instantiation self, std::string const & var, gum::Idx newval) -> Instantiation\n"
		"Instantiation_chgVal(Instantiation self, std::string const & var, std::string const & newval) -> Instantiation\n"
		"\n"
		"Assign newval to v (or to the variable at position varPos) in the Instantiation.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable or string\n"
		"  The variable whose value is assigned (or its name)\n"
		"varPos : int\n"
		"  The index of the variable whose value is assigned in the tuple of variables of the Instantiation\n"
		"newval : int or string\n"
		"  The index of the value assigned (or its name)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Instantiation\n"
		"    The modified instantiation\n"
		"\n"
		"Raises\n"
		"------\n"
		"NotFound\n"
		"  If variable v does not belong to the instantiation.\n"
		"OutOfBound\n"
		"  If newval is not a possible value for the variable.\n"
		"\n"
		""},
	 { "Instantiation_setVals", _wrap_Instantiation_setVals, METH_VARARGS, "\n"
		"Instantiation_setVals(Instantiation self, Instantiation i) -> Instantiation\n"
		"\n"
		"Assign the values from i in the Instantiation.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyAgrum.Instantiation\n"
		"  An Instantiation in which the new values are searched\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Instantiation\n"
		"  a reference to the instantiation\n"
		"\n"
		""},
	 { "Instantiation_contains", _wrap_Instantiation_contains, METH_VARARGS, "\n"
		"Instantiation_contains(Instantiation self, DiscreteVariable v) -> bool\n"
		"Instantiation_contains(Instantiation self, DiscreteVariable v) -> bool\n"
		"\n"
		"Indicates whether a given variable belongs to the Instantiation.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		"    The variable for which the test is made.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool :\n"
		"    True if the variable is in the Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_variablesSequence", _wrap_Instantiation_variablesSequence, METH_O, "\n"
		"Instantiation_variablesSequence(Instantiation self) -> gum::Sequence< gum::DiscreteVariable const * > const &\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"    the sequence of DiscreteVariable of this instantiation.\n"
		"\n"
		""},
	 { "Instantiation_empty", _wrap_Instantiation_empty, METH_O, "\n"
		"Instantiation_empty(Instantiation self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the instantiation is empty.\n"
		"\n"
		""},
	 { "Instantiation_inOverflow", _wrap_Instantiation_inOverflow, METH_O, "\n"
		"Instantiation_inOverflow(Instantiation self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if the current value of the tuple is correct\n"
		"\n"
		""},
	 { "Instantiation_unsetOverflow", _wrap_Instantiation_unsetOverflow, METH_O, "\n"
		"Instantiation_unsetOverflow(Instantiation self)\n"
		"\n"
		"Removes the flag overflow.\n"
		"\n"
		""},
	 { "Instantiation_unsetEnd", _wrap_Instantiation_unsetEnd, METH_O, "\n"
		"Instantiation_unsetEnd(Instantiation self)\n"
		"\n"
		"Alias for unsetOverflow().\n"
		"\n"
		""},
	 { "Instantiation_end", _wrap_Instantiation_end, METH_O, "\n"
		"Instantiation_end(Instantiation self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the Instantiation reached the end.\n"
		"\n"
		""},
	 { "Instantiation_rend", _wrap_Instantiation_rend, METH_O, "\n"
		"Instantiation_rend(Instantiation self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool:\n"
		"  True if the Instantiation reached the rend.\n"
		"\n"
		""},
	 { "Instantiation_inc", _wrap_Instantiation_inc, METH_O, "\n"
		"Instantiation_inc(Instantiation self)\n"
		"\n"
		"Operator ++.\n"
		"\n"
		""},
	 { "Instantiation_dec", _wrap_Instantiation_dec, METH_O, "\n"
		"Instantiation_dec(Instantiation self)\n"
		"\n"
		"Operator --.\n"
		"\n"
		""},
	 { "Instantiation_incIn", _wrap_Instantiation_incIn, METH_VARARGS, "\n"
		"Instantiation_incIn(Instantiation self, Instantiation i)\n"
		"\n"
		"Operator ++ for the variables in i.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyAgrum.Instantiation\n"
		"    The set of variables to increment in this Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_decIn", _wrap_Instantiation_decIn, METH_VARARGS, "\n"
		"Instantiation_decIn(Instantiation self, Instantiation i)\n"
		"\n"
		"Operator -- for the variables in i.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyAgrum.Instantiation\n"
		"  The set of variables to decrement in this Instantiation\n"
		"\n"
		""},
	 { "Instantiation_incOut", _wrap_Instantiation_incOut, METH_VARARGS, "\n"
		"Instantiation_incOut(Instantiation self, Instantiation i)\n"
		"\n"
		"Operator ++ for the variables not in i.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : Instantiation\n"
		"    The set of variable to not increment in this Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_decOut", _wrap_Instantiation_decOut, METH_VARARGS, "\n"
		"Instantiation_decOut(Instantiation self, Instantiation i)\n"
		"\n"
		"Operator -- for the variables not in i.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyAgrum.Instantiation\n"
		"  The set of variables to not decrement in this Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_incNotVar", _wrap_Instantiation_incNotVar, METH_VARARGS, "\n"
		"Instantiation_incNotVar(Instantiation self, DiscreteVariable v)\n"
		"\n"
		"Operator ++ for vars which are not v.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		"    The variable not to increment in this Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_decNotVar", _wrap_Instantiation_decNotVar, METH_VARARGS, "\n"
		"Instantiation_decNotVar(Instantiation self, DiscreteVariable v)\n"
		"\n"
		"Operator -- for vars which are not v.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		"  The variable not to decrement in this Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_incVar", _wrap_Instantiation_incVar, METH_VARARGS, "\n"
		"Instantiation_incVar(Instantiation self, DiscreteVariable v)\n"
		"\n"
		"Operator ++ for variable v only.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		"    The variable to increment in this Instantiation.\n"
		"\n"
		"Raises\n"
		"------\n"
		"NotFound\n"
		"  If variable v does not belong to the Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_decVar", _wrap_Instantiation_decVar, METH_VARARGS, "\n"
		"Instantiation_decVar(Instantiation self, DiscreteVariable v)\n"
		"\n"
		"Operator -- for variable v only.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		" The variable to decrement in this Instantiation.\n"
		"\n"
		"Raises\n"
		"------\n"
		"NotFound\n"
		"  If variable v does not belong to the Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_setFirst", _wrap_Instantiation_setFirst, METH_O, "\n"
		"Instantiation_setFirst(Instantiation self)\n"
		"\n"
		"Assign the first values to the tuple of the Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_setLast", _wrap_Instantiation_setLast, METH_O, "\n"
		"Instantiation_setLast(Instantiation self)\n"
		"\n"
		"Assign the last values in the Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_setFirstIn", _wrap_Instantiation_setFirstIn, METH_VARARGS, "\n"
		"Instantiation_setFirstIn(Instantiation self, Instantiation i)\n"
		"\n"
		"Assign the first values in the Instantiation for the variables in i.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyAgrum.Instantiation\n"
		"  The variables to which their first value is assigned in this Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_setLastIn", _wrap_Instantiation_setLastIn, METH_VARARGS, "\n"
		"Instantiation_setLastIn(Instantiation self, Instantiation i)\n"
		"\n"
		"Assign the last values in the Instantiation for the variables in i.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyAgrum.Instantiation\n"
		"    The variables to which their last value is assigned in this Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_setFirstOut", _wrap_Instantiation_setFirstOut, METH_VARARGS, "\n"
		"Instantiation_setFirstOut(Instantiation self, Instantiation i)\n"
		"\n"
		"Assign the first values in the Instantiation for the variables not in i.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyAgrum.Instantiation\n"
		"    The variable that will not be set to their first value in this Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_setLastOut", _wrap_Instantiation_setLastOut, METH_VARARGS, "\n"
		"Instantiation_setLastOut(Instantiation self, Instantiation i)\n"
		"\n"
		"Assign the last values in the Instantiation for the variables not in i.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyAgrum.Instantiation\n"
		"    The variables that will not be set to their last value in this Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_setFirstNotVar", _wrap_Instantiation_setFirstNotVar, METH_VARARGS, "\n"
		"Instantiation_setFirstNotVar(Instantiation self, DiscreteVariable v)\n"
		"\n"
		"Assign the first values to variables different of v.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		"  The variable that will not be set to its first value in this Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_setLastNotVar", _wrap_Instantiation_setLastNotVar, METH_VARARGS, "\n"
		"Instantiation_setLastNotVar(Instantiation self, DiscreteVariable v)\n"
		"\n"
		"Assign the last values to variables different of v.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		"    The variable that will not be set to its last value in this Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_setFirstVar", _wrap_Instantiation_setFirstVar, METH_VARARGS, "\n"
		"Instantiation_setFirstVar(Instantiation self, DiscreteVariable v)\n"
		"\n"
		"Assign the first value in the Instantiation for var v.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		"    The variable that will be set to its first value in this Instantiation.\n"
		"\n"
		""},
	 { "Instantiation_setLastVar", _wrap_Instantiation_setLastVar, METH_VARARGS, "\n"
		"Instantiation_setLastVar(Instantiation self, DiscreteVariable v)\n"
		"\n"
		"Assign the last value in the Instantiation for var v.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		"  The variable that will be set to its last value in this Instantiation.\n"
		"\n"
		""},
	 { "Instantiation___eq__", _wrap_Instantiation___eq__, METH_VARARGS, "Instantiation___eq__(Instantiation self, Instantiation other) -> bool"},
	 { "Instantiation___iadd__", _wrap_Instantiation___iadd__, METH_VARARGS, "Instantiation___iadd__(Instantiation self, gum::Size depl) -> Instantiation"},
	 { "Instantiation___isub__", _wrap_Instantiation___isub__, METH_VARARGS, "Instantiation___isub__(Instantiation self, gum::Size depl) -> Instantiation"},
	 { "Instantiation_hamming", _wrap_Instantiation_hamming, METH_O, "\n"
		"Instantiation_hamming(Instantiation self) -> gum::Idx\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the hamming distance of this instantiation.\n"
		"\n"
		""},
	 { "Instantiation_reorder", _wrap_Instantiation_reorder, METH_VARARGS, "\n"
		"Instantiation_reorder(Instantiation self, gum::Sequence< gum::DiscreteVariable const * > const & v)\n"
		"Instantiation_reorder(Instantiation self, Instantiation i)\n"
		"\n"
		"Reorder vars of this instantiation giving the order in v (or i).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyAgrum.Instantiation\n"
		"  The sequence of variables with which to reorder this Instantiation.\n"
		"v : list\n"
		"    The new order of variables for this Instantiation.\n"
		"\n"
		""},
	 { "Instantiation___repr__", _wrap_Instantiation___repr__, METH_O, "Instantiation___repr__(Instantiation self) -> std::string"},
	 { "Instantiation___str__", _wrap_Instantiation___str__, METH_O, "Instantiation___str__(Instantiation self) -> std::string"},
	 { "Instantiation_todict", _wrap_Instantiation_todict, METH_VARARGS, "\n"
		"Instantiation_todict(Instantiation self, bool withLabels=False) -> PyObject\n"
		"\n"
		"Create a dict (variable_name:value) from an instantiation\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"withLabels : boolean\n"
		"	The value will be a label (string) if True. It will be a position (int) if False.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Dict\n"
		"    The dictionary\n"
		"\n"
		""},
	 { "Instantiation_fromdict", _wrap_Instantiation_fromdict, METH_VARARGS, "\n"
		"Instantiation_fromdict(Instantiation self, PyObject * dict)\n"
		"\n"
		"Change the values in an instantiation from a dict (variable_name:value) where value can be a position (int) or a label (string).\n"
		"\n"
		"If a variable_name does not occur in the instantiation, nothing is done.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"    OutOfBounds raised if a value cannot be found.\n"
		"\n"
		""},
	 { "Instantiation_swigregister", Instantiation_swigregister, METH_VARARGS, NULL},
	 { "Instantiation_swiginit", Instantiation_swiginit, METH_VARARGS, NULL},
	 { "delete_DAGmodel", _wrap_delete_DAGmodel, METH_O, "delete_DAGmodel(DAGmodel self)"},
	 { "DAGmodel_property", _wrap_DAGmodel_property, METH_VARARGS, "\n"
		"DAGmodel_property(DAGmodel self, std::string const & name) -> std::string const &\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Unreferenced function\n"
		"\n"
		""},
	 { "DAGmodel_propertyWithDefault", _wrap_DAGmodel_propertyWithDefault, METH_VARARGS, "\n"
		"DAGmodel_propertyWithDefault(DAGmodel self, std::string const & name, std::string const & byDefault) -> std::string const &\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Unreferenced function\n"
		"\n"
		""},
	 { "DAGmodel_setProperty", _wrap_DAGmodel_setProperty, METH_VARARGS, "\n"
		"DAGmodel_setProperty(DAGmodel self, std::string const & name, std::string const & value)\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Unreferenced function\n"
		"\n"
		""},
	 { "DAGmodel_dag", _wrap_DAGmodel_dag, METH_O, "\n"
		"DAGmodel_dag(DAGmodel self) -> DAG\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DAG\n"
		"	a constant reference to the dag of this BayesNet.\n"
		"\n"
		""},
	 { "DAGmodel_variableNodeMap", _wrap_DAGmodel_variableNodeMap, METH_O, "\n"
		"DAGmodel_variableNodeMap(DAGmodel self) -> VariableNodeMap\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.variableNodeMap\n"
		"	the variable node map\n"
		"\n"
		""},
	 { "DAGmodel_size", _wrap_DAGmodel_size, METH_O, "\n"
		"DAGmodel_size(DAGmodel self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of nodes in the graph\n"
		"\n"
		""},
	 { "DAGmodel_sizeArcs", _wrap_DAGmodel_sizeArcs, METH_O, "\n"
		"DAGmodel_sizeArcs(DAGmodel self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of arcs in the graph\n"
		"\n"
		""},
	 { "DAGmodel_empty", _wrap_DAGmodel_empty, METH_O, "\n"
		"DAGmodel_empty(DAGmodel self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the model is empty\n"
		"\n"
		""},
	 { "DAGmodel_nodes", _wrap_DAGmodel_nodes, METH_O, "\n"
		"DAGmodel_nodes(DAGmodel self) -> NodeGraphPart\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of ids\n"
		"\n"
		""},
	 { "DAGmodel_variable", _wrap_DAGmodel_variable, METH_VARARGS, "\n"
		"DAGmodel_variable(DAGmodel self, gum::NodeId id) -> DiscreteVariable\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	a variable's id\n"
		"name : str\n"
		"	a variable's name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DiscreteVariable\n"
		"	the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "DAGmodel_nodeId", _wrap_DAGmodel_nodeId, METH_VARARGS, "\n"
		"DAGmodel_nodeId(DAGmodel self, DiscreteVariable var) -> gum::NodeId\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : pyAgrum.DiscreteVariable\n"
		"	a variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "DAGmodel_idFromName", _wrap_DAGmodel_idFromName, METH_VARARGS, "\n"
		"DAGmodel_idFromName(DAGmodel self, std::string const & name) -> gum::NodeId\n"
		"\n"
		"Returns a variable's id given its name in the graph.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	The variable's name from which the id is returned.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	The variable's node id.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"	If name does not match a variable in the graph\n"
		"\n"
		""},
	 { "DAGmodel_variableFromName", _wrap_DAGmodel_variableFromName, METH_VARARGS, "\n"
		"DAGmodel_variableFromName(DAGmodel self, std::string const & name) -> DiscreteVariable\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	a variable's name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DiscreteVariable\n"
		"	the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "DAGmodel_completeInstantiation", _wrap_DAGmodel_completeInstantiation, METH_O, "\n"
		"DAGmodel_completeInstantiation(DAGmodel self) -> Instantiation\n"
		"\n"
		"Get an instantiation over all the variables of the model.\n"
		"\n"
		"Returns\n"
		"----------\n"
		"pyAgrum.instantiation\n"
		"	the complete instantiation\n"
		"\n"
		""},
	 { "DAGmodel_arcs", _wrap_DAGmodel_arcs, METH_O, "\n"
		"DAGmodel_arcs(DAGmodel self) -> gum::ArcSet const &\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	The lisf of arcs in the graph\n"
		"\n"
		""},
	 { "DAGmodel_parents", _wrap_DAGmodel_parents, METH_VARARGS, "\n"
		"DAGmodel_parents(DAGmodel self, gum::NodeId const id) -> gum::NodeSet const\n"
		"DAGmodel_parents(DAGmodel self, std::string const & name) -> gum::NodeSet const &\n"
		""},
	 { "DAGmodel_children", _wrap_DAGmodel_children, METH_VARARGS, "\n"
		"DAGmodel_children(DAGmodel self, gum::NodeId const id) -> gum::NodeSet const\n"
		"DAGmodel_children(DAGmodel self, std::string const & name) -> gum::NodeSet const &\n"
		""},
	 { "DAGmodel_moralGraph", _wrap_DAGmodel_moralGraph, METH_VARARGS, "\n"
		"DAGmodel_moralGraph(DAGmodel self, bool clear=True) -> UndiGraph\n"
		"\n"
		"Returns the moral graph of the BayesNet, formed by adding edges between all pairs of nodes that have a common child, and then making all edges in the graph undirected.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.UndiGraph\n"
		"	The moral graph\n"
		"\n"
		""},
	 { "DAGmodel_topologicalOrder", _wrap_DAGmodel_topologicalOrder, METH_VARARGS, "\n"
		"DAGmodel_topologicalOrder(DAGmodel self, bool clear=True) -> gum::Sequence< gum::NodeId > const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"    the list of the nodes Ids in a topological order\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidDirectedCycle\n"
		"	If this graph contains cycles\n"
		"\n"
		""},
	 { "DAGmodel_log10DomainSize", _wrap_DAGmodel_log10DomainSize, METH_O, "\n"
		"DAGmodel_log10DomainSize(DAGmodel self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	The log10 domain size of the joint probability for the model.\n"
		"\n"
		""},
	 { "DAGmodel_hasSameStructure", _wrap_DAGmodel_hasSameStructure, METH_VARARGS, "\n"
		"DAGmodel_hasSameStructure(DAGmodel self, DAGmodel other) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pyAgrum.DAGmodel\n"
		"	a direct acyclic model\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if all the named node are the same and all the named arcs are the same\n"
		"\n"
		""},
	 { "DAGmodel_swigregister", DAGmodel_swigregister, METH_VARARGS, NULL},
	 { "new_EssentialGraph", _wrap_new_EssentialGraph, METH_VARARGS, "\n"
		"EssentialGraph()\n"
		"EssentialGraph(DAGmodel m)\n"
		"EssentialGraph(DAGmodel m, MixedGraph mg)\n"
		"new_EssentialGraph(EssentialGraph g) -> EssentialGraph\n"
		""},
	 { "delete_EssentialGraph", _wrap_delete_EssentialGraph, METH_O, "delete_EssentialGraph(EssentialGraph self)"},
	 { "EssentialGraph_mixedGraph", _wrap_EssentialGraph_mixedGraph, METH_O, "\n"
		"EssentialGraph_mixedGraph(EssentialGraph self) -> MixedGraph\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.MixedGraph\n"
		"	the mixed graph\n"
		"\n"
		""},
	 { "EssentialGraph_toDot", _wrap_EssentialGraph_toDot, METH_O, "\n"
		"EssentialGraph_toDot(EssentialGraph self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a friendly display of the graph in DOT format \n"
		"\n"
		""},
	 { "EssentialGraph_sizeArcs", _wrap_EssentialGraph_sizeArcs, METH_O, "\n"
		"EssentialGraph_sizeArcs(EssentialGraph self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of arcs in the graph\n"
		"\n"
		""},
	 { "EssentialGraph_sizeEdges", _wrap_EssentialGraph_sizeEdges, METH_O, "\n"
		"EssentialGraph_sizeEdges(EssentialGraph self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of edges in the graph\n"
		"\n"
		""},
	 { "EssentialGraph_sizeNodes", _wrap_EssentialGraph_sizeNodes, METH_O, "\n"
		"EssentialGraph_sizeNodes(EssentialGraph self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of nodes in the graph\n"
		"\n"
		""},
	 { "EssentialGraph_size", _wrap_EssentialGraph_size, METH_O, "\n"
		"EssentialGraph_size(EssentialGraph self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of nodes in the graph\n"
		"\n"
		""},
	 { "EssentialGraph_nodes", _wrap_EssentialGraph_nodes, METH_O, "EssentialGraph_nodes(EssentialGraph self) -> PyObject *"},
	 { "EssentialGraph_arcs", _wrap_EssentialGraph_arcs, METH_O, "\n"
		"EssentialGraph_arcs(EssentialGraph self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	The lisf of arcs in the EssentialGraph\n"
		"\n"
		""},
	 { "EssentialGraph_parents", _wrap_EssentialGraph_parents, METH_VARARGS, "\n"
		"EssentialGraph_parents(EssentialGraph self, gum::NodeId id) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id :\n"
		"	The id of the child node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"    the set of the parents ids.\n"
		"\n"
		""},
	 { "EssentialGraph_children", _wrap_EssentialGraph_children, METH_VARARGS, "\n"
		"EssentialGraph_children(EssentialGraph self, gum::NodeId id) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  the id of the parent\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"	the set of all the children\n"
		"\n"
		""},
	 { "EssentialGraph_edges", _wrap_EssentialGraph_edges, METH_O, "\n"
		"EssentialGraph_edges(EssentialGraph self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"  the list of the edges\n"
		"\n"
		""},
	 { "EssentialGraph_neighbours", _wrap_EssentialGraph_neighbours, METH_VARARGS, "\n"
		"EssentialGraph_neighbours(EssentialGraph self, gum::NodeId id) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"    the id of the checked node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"    The set of edges adjacent to the given node \n"
		"\n"
		""},
	 { "EssentialGraph_swigregister", EssentialGraph_swigregister, METH_VARARGS, NULL},
	 { "EssentialGraph_swiginit", EssentialGraph_swiginit, METH_VARARGS, NULL},
	 { "new_MarkovBlanket", _wrap_new_MarkovBlanket, METH_VARARGS, "\n"
		"MarkovBlanket(DAGmodel m, gum::NodeId n)\n"
		"new_MarkovBlanket(DAGmodel m, std::string const & name) -> MarkovBlanket\n"
		""},
	 { "delete_MarkovBlanket", _wrap_delete_MarkovBlanket, METH_O, "delete_MarkovBlanket(MarkovBlanket self)"},
	 { "MarkovBlanket_mb", _wrap_MarkovBlanket_mb, METH_O, "\n"
		"MarkovBlanket_mb(MarkovBlanket self) -> DiGraph\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DiGraph\n"
		"  a copy of the directed graph\n"
		"\n"
		""},
	 { "MarkovBlanket_toDot", _wrap_MarkovBlanket_toDot, METH_O, "\n"
		"MarkovBlanket_toDot(MarkovBlanket self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a friendly display of the graph in DOT format \n"
		"\n"
		""},
	 { "MarkovBlanket_sizeArcs", _wrap_MarkovBlanket_sizeArcs, METH_O, "\n"
		"MarkovBlanket_sizeArcs(MarkovBlanket self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of arcs in the graph\n"
		"\n"
		""},
	 { "MarkovBlanket_sizeNodes", _wrap_MarkovBlanket_sizeNodes, METH_O, "\n"
		"MarkovBlanket_sizeNodes(MarkovBlanket self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of nodes in the graph\n"
		"\n"
		""},
	 { "MarkovBlanket_size", _wrap_MarkovBlanket_size, METH_O, "\n"
		"MarkovBlanket_size(MarkovBlanket self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of nodes in the graph\n"
		"\n"
		""},
	 { "MarkovBlanket_hasSameStructure", _wrap_MarkovBlanket_hasSameStructure, METH_VARARGS, "\n"
		"MarkovBlanket_hasSameStructure(MarkovBlanket self, DAGmodel other) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pyAgrum.DAGmodel\n"
		"	a direct acyclic model\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if all the named node are the same and all the named arcs are the same \n"
		"\n"
		""},
	 { "MarkovBlanket_nodes", _wrap_MarkovBlanket_nodes, METH_O, "\n"
		"MarkovBlanket_nodes(MarkovBlanket self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of ids\n"
		"\n"
		""},
	 { "MarkovBlanket_arcs", _wrap_MarkovBlanket_arcs, METH_O, "\n"
		"MarkovBlanket_arcs(MarkovBlanket self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List\n"
		"	the list of the arcs\n"
		"\n"
		""},
	 { "MarkovBlanket_parents", _wrap_MarkovBlanket_parents, METH_VARARGS, "\n"
		"MarkovBlanket_parents(MarkovBlanket self, gum::NodeId id) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id :\n"
		"	The id of the child node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"    the set of the parents ids.\n"
		"\n"
		""},
	 { "MarkovBlanket_children", _wrap_MarkovBlanket_children, METH_VARARGS, "\n"
		"MarkovBlanket_children(MarkovBlanket self, gum::NodeId id) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  the id of the parent\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"	the set of all the children\n"
		"\n"
		""},
	 { "MarkovBlanket_swigregister", MarkovBlanket_swigregister, METH_VARARGS, NULL},
	 { "MarkovBlanket_swiginit", MarkovBlanket_swiginit, METH_VARARGS, NULL},
	 { "new_StructuralComparator", _wrap_new_StructuralComparator, METH_NOARGS, "new_StructuralComparator() -> StructuralComparator"},
	 { "delete_StructuralComparator", _wrap_delete_StructuralComparator, METH_O, "delete_StructuralComparator(StructuralComparator self)"},
	 { "StructuralComparator_compare", _wrap_StructuralComparator_compare, METH_VARARGS, "\n"
		"StructuralComparator_compare(StructuralComparator self, DiGraph ref, DiGraph test)\n"
		"StructuralComparator_compare(StructuralComparator self, UndiGraph ref, UndiGraph test)\n"
		"StructuralComparator_compare(StructuralComparator self, MixedGraph ref, MixedGraph test)\n"
		"\n"
		"Use to compare the edges/arcs of two structure of the same type and same sizes (either DiGraph, UndiGraph or MixedGraph).\n"
		"\n"
		"Could be use to compare a BN and its learned version.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"ref :\n"
		"	the structure of reference\n"
		"test :\n"
		"	the structure we want to test\n"
		"\n"
		""},
	 { "StructuralComparator_precision_skeleton", _wrap_StructuralComparator_precision_skeleton, METH_O, "\n"
		"StructuralComparator_precision_skeleton(StructuralComparator self) -> double\n"
		"\n"
		"Rate of true postive over labelized edges.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the precision of the tested graph skeleton\n"
		"\n"
		""},
	 { "StructuralComparator_recall_skeleton", _wrap_StructuralComparator_recall_skeleton, METH_O, "\n"
		"StructuralComparator_recall_skeleton(StructuralComparator self) -> double\n"
		"\n"
		"Rate of true postive over labelized edges.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the recall of the tested graph skeleton\n"
		"\n"
		""},
	 { "StructuralComparator_f_score_skeleton", _wrap_StructuralComparator_f_score_skeleton, METH_O, "\n"
		"StructuralComparator_f_score_skeleton(StructuralComparator self) -> double\n"
		"\n"
		"Harmonic mean between recall and precision.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the tarmonic mean of the tested graph skeleton\n"
		"\n"
		""},
	 { "StructuralComparator_precision", _wrap_StructuralComparator_precision, METH_O, "\n"
		"StructuralComparator_precision(StructuralComparator self) -> double\n"
		"\n"
		"Rate of true postive over postively labelized arcs/edges.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the precision of the tested graph\n"
		"\n"
		""},
	 { "StructuralComparator_recall", _wrap_StructuralComparator_recall, METH_O, "\n"
		"StructuralComparator_recall(StructuralComparator self) -> double\n"
		"\n"
		"Rate of true postive over labelized arcs/edges.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the recall of the tested graph\n"
		"\n"
		""},
	 { "StructuralComparator_f_score", _wrap_StructuralComparator_f_score, METH_O, "\n"
		"StructuralComparator_f_score(StructuralComparator self) -> double\n"
		"\n"
		"Harmonic mean between recall and precision.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the harmonic mean of the tested graph\n"
		"\n"
		""},
	 { "StructuralComparator_swigregister", StructuralComparator_swigregister, METH_VARARGS, NULL},
	 { "StructuralComparator_swiginit", StructuralComparator_swiginit, METH_VARARGS, NULL},
	 { "new_ApproximationScheme", _wrap_new_ApproximationScheme, METH_VARARGS, "ApproximationScheme(bool v=False)"},
	 { "delete_ApproximationScheme", _wrap_delete_ApproximationScheme, METH_O, "delete_ApproximationScheme(ApproximationScheme self)"},
	 { "ApproximationScheme_setEpsilon", _wrap_ApproximationScheme_setEpsilon, METH_VARARGS, "\n"
		"ApproximationScheme_setEpsilon(ApproximationScheme self, double eps)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : double\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "ApproximationScheme_epsilon", _wrap_ApproximationScheme_epsilon, METH_O, "\n"
		"ApproximationScheme_epsilon(ApproximationScheme self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "ApproximationScheme_disableEpsilon", _wrap_ApproximationScheme_disableEpsilon, METH_O, "\n"
		"ApproximationScheme_disableEpsilon(ApproximationScheme self)\n"
		"\n"
		"Disable epsilon as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_enableEpsilon", _wrap_ApproximationScheme_enableEpsilon, METH_O, "\n"
		"ApproximationScheme_enableEpsilon(ApproximationScheme self)\n"
		"\n"
		"Enable epsilon as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_isEnabledEpsilon", _wrap_ApproximationScheme_isEnabledEpsilon, METH_O, "\n"
		"ApproximationScheme_isEnabledEpsilon(ApproximationScheme self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if epsilon is used as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_setMinEpsilonRate", _wrap_ApproximationScheme_setMinEpsilonRate, METH_VARARGS, "\n"
		"ApproximationScheme_setMinEpsilonRate(ApproximationScheme self, double rate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : double\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "ApproximationScheme_minEpsilonRate", _wrap_ApproximationScheme_minEpsilonRate, METH_O, "\n"
		"ApproximationScheme_minEpsilonRate(ApproximationScheme self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "ApproximationScheme_disableMinEpsilonRate", _wrap_ApproximationScheme_disableMinEpsilonRate, METH_O, "\n"
		"ApproximationScheme_disableMinEpsilonRate(ApproximationScheme self)\n"
		"\n"
		"Disable a min epsilon rate as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_enableMinEpsilonRate", _wrap_ApproximationScheme_enableMinEpsilonRate, METH_O, "\n"
		"ApproximationScheme_enableMinEpsilonRate(ApproximationScheme self)\n"
		"\n"
		"Enable a min epsilon rate as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_isEnabledMinEpsilonRate", _wrap_ApproximationScheme_isEnabledMinEpsilonRate, METH_O, "\n"
		"ApproximationScheme_isEnabledMinEpsilonRate(ApproximationScheme self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if epsilon rate is used as a stopping criterion\n"
		"\n"
		""},
	 { "ApproximationScheme_setMaxIter", _wrap_ApproximationScheme_setMaxIter, METH_VARARGS, "\n"
		"ApproximationScheme_setMaxIter(ApproximationScheme self, gum::Size max)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "ApproximationScheme_maxIter", _wrap_ApproximationScheme_maxIter, METH_O, "\n"
		"ApproximationScheme_maxIter(ApproximationScheme self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "ApproximationScheme_disableMaxIter", _wrap_ApproximationScheme_disableMaxIter, METH_O, "\n"
		"ApproximationScheme_disableMaxIter(ApproximationScheme self)\n"
		"\n"
		"Disable max iterations as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_enableMaxIter", _wrap_ApproximationScheme_enableMaxIter, METH_O, "\n"
		"ApproximationScheme_enableMaxIter(ApproximationScheme self)\n"
		"\n"
		"Enable max iterations as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_isEnabledMaxIter", _wrap_ApproximationScheme_isEnabledMaxIter, METH_O, "\n"
		"ApproximationScheme_isEnabledMaxIter(ApproximationScheme self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if max iterations is used as a stopping criterion\n"
		"\n"
		""},
	 { "ApproximationScheme_setMaxTime", _wrap_ApproximationScheme_setMaxTime, METH_VARARGS, "\n"
		"ApproximationScheme_setMaxTime(ApproximationScheme self, double timeout)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : double\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "ApproximationScheme_maxTime", _wrap_ApproximationScheme_maxTime, METH_O, "\n"
		"ApproximationScheme_maxTime(ApproximationScheme self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "ApproximationScheme_currentTime", _wrap_ApproximationScheme_currentTime, METH_O, "\n"
		"ApproximationScheme_currentTime(ApproximationScheme self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	get the current running time in second (double)\n"
		"\n"
		""},
	 { "ApproximationScheme_disableMaxTime", _wrap_ApproximationScheme_disableMaxTime, METH_O, "\n"
		"ApproximationScheme_disableMaxTime(ApproximationScheme self)\n"
		"\n"
		"Disable max time as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_enableMaxTime", _wrap_ApproximationScheme_enableMaxTime, METH_O, "\n"
		"ApproximationScheme_enableMaxTime(ApproximationScheme self)\n"
		"\n"
		"Enable max time as a stopping criterion.\n"
		"\n"
		""},
	 { "ApproximationScheme_isEnabledMaxTime", _wrap_ApproximationScheme_isEnabledMaxTime, METH_O, "\n"
		"ApproximationScheme_isEnabledMaxTime(ApproximationScheme self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if max time is used as a stopping criterion\n"
		"\n"
		""},
	 { "ApproximationScheme_setPeriodSize", _wrap_ApproximationScheme_setPeriodSize, METH_VARARGS, "\n"
		"ApproximationScheme_setPeriodSize(ApproximationScheme self, gum::Size p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "ApproximationScheme_periodSize", _wrap_ApproximationScheme_periodSize, METH_O, "\n"
		"ApproximationScheme_periodSize(ApproximationScheme self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "ApproximationScheme_setVerbosity", _wrap_ApproximationScheme_setVerbosity, METH_VARARGS, "\n"
		"ApproximationScheme_setVerbosity(ApproximationScheme self, bool v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "ApproximationScheme_verbosity", _wrap_ApproximationScheme_verbosity, METH_O, "\n"
		"ApproximationScheme_verbosity(ApproximationScheme self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "ApproximationScheme_stateApproximationScheme", _wrap_ApproximationScheme_stateApproximationScheme, METH_O, "\n"
		"ApproximationScheme_stateApproximationScheme(ApproximationScheme self) -> gum::IApproximationSchemeConfiguration::ApproximationSchemeSTATE\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the state of the approximation scheme\n"
		"\n"
		""},
	 { "ApproximationScheme_nbrIterations", _wrap_ApproximationScheme_nbrIterations, METH_O, "\n"
		"ApproximationScheme_nbrIterations(ApproximationScheme self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "ApproximationScheme_history", _wrap_ApproximationScheme_history, METH_O, "\n"
		"ApproximationScheme_history(ApproximationScheme self) -> Vector\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "ApproximationScheme_initApproximationScheme", _wrap_ApproximationScheme_initApproximationScheme, METH_O, "\n"
		"ApproximationScheme_initApproximationScheme(ApproximationScheme self)\n"
		"\n"
		"Initiate the approximation scheme.\n"
		"\n"
		""},
	 { "ApproximationScheme_startOfPeriod", _wrap_ApproximationScheme_startOfPeriod, METH_O, "\n"
		"ApproximationScheme_startOfPeriod(ApproximationScheme self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if it is a start of a period\n"
		"\n"
		""},
	 { "ApproximationScheme_updateApproximationScheme", _wrap_ApproximationScheme_updateApproximationScheme, METH_VARARGS, "\n"
		"ApproximationScheme_updateApproximationScheme(ApproximationScheme self, unsigned int incr=1)\n"
		"\n"
		"Update the approximation scheme.\n"
		"\n"
		""},
	 { "ApproximationScheme_remainingBurnIn", _wrap_ApproximationScheme_remainingBurnIn, METH_O, "\n"
		"ApproximationScheme_remainingBurnIn(ApproximationScheme self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of remaining burn in\n"
		"\n"
		""},
	 { "ApproximationScheme_stopApproximationScheme", _wrap_ApproximationScheme_stopApproximationScheme, METH_O, "\n"
		"ApproximationScheme_stopApproximationScheme(ApproximationScheme self)\n"
		"\n"
		"Stop the approximation scheme.\n"
		"\n"
		""},
	 { "ApproximationScheme_continueApproximationScheme", _wrap_ApproximationScheme_continueApproximationScheme, METH_VARARGS, "\n"
		"ApproximationScheme_continueApproximationScheme(ApproximationScheme self, double error) -> bool\n"
		"\n"
		"Continue the approximation scheme.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"error : double\n"
		"\n"
		""},
	 { "ApproximationScheme_swigregister", ApproximationScheme_swigregister, METH_VARARGS, NULL},
	 { "ApproximationScheme_swiginit", ApproximationScheme_swiginit, METH_VARARGS, NULL},
	 { "randomDistribution", _wrap_randomDistribution, METH_O, "\n"
		"randomDistribution(gum::Size n) -> Vector\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n : int\n"
		"  The number of modalities for the ditribution.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"a random discrete distribution. \n"
		"\n"
		""},
	 { "new_DiscretizedVariable", _wrap_new_DiscretizedVariable, METH_VARARGS, "\n"
		"DiscretizedVariable(std::string const & aName, std::string const & aDesc)\n"
		"DiscretizedVariable(std::string const & aName, std::string const & aDesc, Vector ticks)\n"
		"new_DiscretizedVariable(DiscretizedVariable aDRV) -> DiscretizedVariable\n"
		""},
	 { "delete_DiscretizedVariable", _wrap_delete_DiscretizedVariable, METH_O, "delete_DiscretizedVariable(DiscretizedVariable self)"},
	 { "DiscretizedVariable_clone", _wrap_DiscretizedVariable_clone, METH_O, "\n"
		"DiscretizedVariable_clone(DiscretizedVariable self) -> DiscretizedVariable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DiscretizedVariable\n"
		"	a copy of the DiscretizedVariable\n"
		"\n"
		""},
	 { "DiscretizedVariable_varType", _wrap_DiscretizedVariable_varType, METH_O, "\n"
		"DiscretizedVariable_varType(DiscretizedVariable self) -> gum::VarType\n"
		"\n"
		"returns the type of variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	the type of the variable, 0: DiscretizedVariable, 1: LabelizedVariable, 2: RangeVariable\n"
		"\n"
		""},
	 { "DiscretizedVariable_isTick", _wrap_DiscretizedVariable_isTick, METH_VARARGS, "\n"
		"DiscretizedVariable_isTick(DiscretizedVariable self, double const & aTick) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"aTick : double\n"
		"	the Tick to be tested\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool :\n"
		"	True if the Tick already exists\n"
		"\n"
		""},
	 { "DiscretizedVariable_addTick", _wrap_DiscretizedVariable_addTick, METH_VARARGS, "\n"
		"DiscretizedVariable_addTick(DiscretizedVariable self, double const & aTick) -> DiscretizedVariable\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"aTick : double\n"
		"	the Tick to be added\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DiscretizedVariable\n"
		"	the discretized variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.DefaultInLabel\n"
		"	If the Tick is already defined\n"
		"\n"
		""},
	 { "DiscretizedVariable_eraseTicks", _wrap_DiscretizedVariable_eraseTicks, METH_O, "\n"
		"DiscretizedVariable_eraseTicks(DiscretizedVariable self)\n"
		"\n"
		"erase all the Ticks \n"
		"\n"
		""},
	 { "DiscretizedVariable_label", _wrap_DiscretizedVariable_label, METH_VARARGS, "\n"
		"DiscretizedVariable_label(DiscretizedVariable self, gum::Idx i) -> std::string\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : int\n"
		"	the index of the label we wish to return\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the indice-th label\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfBound\n"
		"	If the variable does not contain the label\n"
		"\n"
		""},
	 { "DiscretizedVariable_numerical", _wrap_DiscretizedVariable_numerical, METH_VARARGS, "\n"
		"DiscretizedVariable_numerical(DiscretizedVariable self, gum::Idx indice) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"indice : int\n"
		"	an index\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"	the numerical representation of the indice-th value\n"
		"\n"
		""},
	 { "DiscretizedVariable_index", _wrap_DiscretizedVariable_index, METH_VARARGS, "\n"
		"DiscretizedVariable_index(DiscretizedVariable self, std::string const & label) -> gum::Idx\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"label : str\n"
		"	a label\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the indice of the label\n"
		"\n"
		""},
	 { "DiscretizedVariable_domainSize", _wrap_DiscretizedVariable_domainSize, METH_O, "\n"
		"DiscretizedVariable_domainSize(DiscretizedVariable self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of modalities in the variable domain\n"
		"\n"
		""},
	 { "DiscretizedVariable_domain", _wrap_DiscretizedVariable_domain, METH_O, "\n"
		"DiscretizedVariable_domain(DiscretizedVariable self) -> std::string const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    the domain of the variable as a string\n"
		"\n"
		""},
	 { "DiscretizedVariable_tick", _wrap_DiscretizedVariable_tick, METH_VARARGS, "\n"
		"DiscretizedVariable_tick(DiscretizedVariable self, gum::Idx i) -> double const &\n"
		"\n"
		"Indicate the index of the Tick\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : int\n"
		"	the index of the Tick\n"
		"\n"
		"Returns\n"
		"-------\n"
		"aTick : double\n"
		"	the index-th Tick\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"	If the index is greater than the number of Ticks\n"
		"\n"
		""},
	 { "DiscretizedVariable_ticks", _wrap_DiscretizedVariable_ticks, METH_O, "\n"
		"DiscretizedVariable_ticks(DiscretizedVariable self) -> Vector\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple :\n"
		"	a tuple containing all the Ticks\n"
		"\n"
		""},
	 { "DiscretizedVariable___repr__", _wrap_DiscretizedVariable___repr__, METH_O, "DiscretizedVariable___repr__(DiscretizedVariable self) -> std::string"},
	 { "DiscretizedVariable___str__", _wrap_DiscretizedVariable___str__, METH_O, "DiscretizedVariable___str__(DiscretizedVariable self) -> std::string"},
	 { "DiscretizedVariable_swigregister", DiscretizedVariable_swigregister, METH_VARARGS, NULL},
	 { "DiscretizedVariable_swiginit", DiscretizedVariable_swiginit, METH_VARARGS, NULL},
	 { "delete_MultiDimContainer", _wrap_delete_MultiDimContainer, METH_O, "delete_MultiDimContainer(MultiDimContainer self)"},
	 { "MultiDimContainer_set", _wrap_MultiDimContainer_set, METH_VARARGS, "MultiDimContainer_set(MultiDimContainer self, Instantiation i, double const & value)"},
	 { "MultiDimContainer_get", _wrap_MultiDimContainer_get, METH_VARARGS, "MultiDimContainer_get(MultiDimContainer self, Instantiation i) -> double"},
	 { "MultiDimContainer_fill", _wrap_MultiDimContainer_fill, METH_VARARGS, "MultiDimContainer_fill(MultiDimContainer self, double const & d)"},
	 { "MultiDimContainer_populate", _wrap_MultiDimContainer_populate, METH_VARARGS, "\n"
		"MultiDimContainer_populate(MultiDimContainer self, Vector v)\n"
		"MultiDimContainer_populate(MultiDimContainer self, std::initializer_list< double > l)\n"
		""},
	 { "MultiDimContainer_copyFrom", _wrap_MultiDimContainer_copyFrom, METH_VARARGS, "\n"
		"MultiDimContainer_copyFrom(MultiDimContainer self, MultiDimContainer src)\n"
		"MultiDimContainer_copyFrom(MultiDimContainer self, MultiDimContainer src, Instantiation p_i)\n"
		""},
	 { "MultiDimContainer_extractFrom", _wrap_MultiDimContainer_extractFrom, METH_VARARGS, "MultiDimContainer_extractFrom(MultiDimContainer self, MultiDimContainer src, Instantiation mask)"},
	 { "MultiDimContainer_content", _wrap_MultiDimContainer_content, METH_VARARGS, "\n"
		"MultiDimContainer_content(MultiDimContainer self) -> gum::MultiDimImplementation< double > const\n"
		"MultiDimContainer_content(MultiDimContainer self) -> gum::MultiDimImplementation< double > *\n"
		""},
	 { "MultiDimContainer_getMasterRef", _wrap_MultiDimContainer_getMasterRef, METH_VARARGS, "\n"
		"MultiDimContainer_getMasterRef(MultiDimContainer self) -> MultiDimAdressable\n"
		"MultiDimContainer_getMasterRef(MultiDimContainer self) -> MultiDimAdressable\n"
		""},
	 { "MultiDimContainer_copy", _wrap_MultiDimContainer_copy, METH_VARARGS, "MultiDimContainer_copy(MultiDimContainer self, MultiDimContainer src)"},
	 { "MultiDimContainer_newFactory", _wrap_MultiDimContainer_newFactory, METH_O, "MultiDimContainer_newFactory(MultiDimContainer self) -> MultiDimContainer"},
	 { "MultiDimContainer_toString", _wrap_MultiDimContainer_toString, METH_VARARGS, "\n"
		"MultiDimContainer_toString(MultiDimContainer self) -> std::string const\n"
		"MultiDimContainer_toString(MultiDimContainer self, Instantiation i) -> std::string const\n"
		""},
	 { "MultiDimContainer___eq__", _wrap_MultiDimContainer___eq__, METH_VARARGS, "MultiDimContainer___eq__(MultiDimContainer self, MultiDimContainer p) -> bool"},
	 { "MultiDimContainer___ne__", _wrap_MultiDimContainer___ne__, METH_VARARGS, "MultiDimContainer___ne__(MultiDimContainer self, MultiDimContainer p) -> bool"},
	 { "MultiDimContainer_apply", _wrap_MultiDimContainer_apply, METH_VARARGS, "MultiDimContainer_apply(MultiDimContainer self, std::function< double (double) > f)"},
	 { "MultiDimContainer_reduce", _wrap_MultiDimContainer_reduce, METH_VARARGS, "MultiDimContainer_reduce(MultiDimContainer self, std::function< double (double,double) > f, double base) -> double"},
	 { "MultiDimContainer_beginMultipleChanges", _wrap_MultiDimContainer_beginMultipleChanges, METH_O, "MultiDimContainer_beginMultipleChanges(MultiDimContainer self)"},
	 { "MultiDimContainer_endMultipleChanges", _wrap_MultiDimContainer_endMultipleChanges, METH_VARARGS, "\n"
		"MultiDimContainer_endMultipleChanges(MultiDimContainer self)\n"
		"MultiDimContainer_endMultipleChanges(MultiDimContainer self, double const & v)\n"
		""},
	 { "MultiDimContainer_swigregister", MultiDimContainer_swigregister, METH_VARARGS, NULL},
	 { "new_Potential", _wrap_new_Potential, METH_VARARGS, "\n"
		"Potential()\n"
		"Potential(gum::MultiDimImplementation< double > * aContent)\n"
		"Potential(gum::MultiDimImplementation< double > * aContent, MultiDimContainer src)\n"
		"Potential(Potential src)\n"
		"new_Potential(Potential _from) -> Potential\n"
		""},
	 { "delete_Potential", _wrap_delete_Potential, METH_O, "delete_Potential(Potential self)"},
	 { "Potential_newFactory", _wrap_Potential_newFactory, METH_O, "\n"
		"Potential_newFactory(Potential self) -> Potential\n"
		"\n"
		"Erase the Potential content and create a new empty one.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		" a reference to the new Potential\n"
		"\n"
		""},
	 { "Potential_isNonZeroMap", _wrap_Potential_isNonZeroMap, METH_O, "\n"
		"Potential_isNonZeroMap(Potential self) -> Potential\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a boolean-like potential using the predicate isNonZero\n"
		"\n"
		""},
	 { "Potential_sum", _wrap_Potential_sum, METH_O, "\n"
		"Potential_sum(Potential self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double :\n"
		"  the sum of all elements in the Potential\n"
		"\n"
		""},
	 { "Potential_product", _wrap_Potential_product, METH_O, "\n"
		"Potential_product(Potential self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the product of all elements in the Potential\n"
		"\n"
		""},
	 { "Potential_max", _wrap_Potential_max, METH_O, "\n"
		"Potential_max(Potential self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the maximum of all elements in the Potential\n"
		"\n"
		""},
	 { "Potential_min", _wrap_Potential_min, METH_O, "\n"
		"Potential_min(Potential self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the min of all elements in the Potential\n"
		"\n"
		""},
	 { "Potential_maxNonOne", _wrap_Potential_maxNonOne, METH_O, "\n"
		"Potential_maxNonOne(Potential self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the maximum of non one elements in the Potential\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"  If all value == 1.0\n"
		"\n"
		""},
	 { "Potential_minNonZero", _wrap_Potential_minNonZero, METH_O, "\n"
		"Potential_minNonZero(Potential self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the min of non zero elements in the Potential\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"  If all value == 0.0\n"
		"\n"
		""},
	 { "Potential_findAll", _wrap_Potential_findAll, METH_VARARGS, "Potential_findAll(Potential self, double v) -> gum::Set< gum::Instantiation >"},
	 { "Potential_argmax", _wrap_Potential_argmax, METH_O, "Potential_argmax(Potential self) -> gum::Set< gum::Instantiation >"},
	 { "Potential_argmin", _wrap_Potential_argmin, METH_O, "Potential_argmin(Potential self) -> gum::Set< gum::Instantiation >"},
	 { "Potential_entropy", _wrap_Potential_entropy, METH_O, "\n"
		"Potential_entropy(Potential self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the entropy of the potential\n"
		"\n"
		""},
	 { "Potential_fillWith", _wrap_Potential_fillWith, METH_VARARGS, "\n"
		"Potential_fillWith(Potential self, Potential src) -> Potential\n"
		"Potential_fillWith(Potential self, Potential src, Vector_string mapSrc) -> Potential\n"
		"Potential_fillWith(Potential self, Vector v) -> Potential\n"
		"Potential_fillWith(Potential self, double const & v) -> Potential\n"
		"\n"
		"Automatically fills the potential with v.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : number or list or pyAgrum.Potential the number of parameters of the Potential\n"
		"    a value or a list/pyAgrum.Potential containing the values to fill the Potential with.\n"
		"\n"
		"Warning\n"
		"-------\n"
		"    if v is a list, the size of the list must be the\n"
		"    if v is a pyAgrum.Potential. It must to contain variables with exactly the same names and labels but not necessarily the same variables.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"      a reference to the modified potentia\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.SizeError\n"
		"  If v size's does not matches the domain size. \n"
		"\n"
		""},
	 { "Potential_abs", _wrap_Potential_abs, METH_O, "\n"
		"Potential_abs(Potential self) -> Potential\n"
		"\n"
		"Apply abs on every element of the container\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"    a reference to the modified potential.\n"
		"\n"
		""},
	 { "Potential_normalize", _wrap_Potential_normalize, METH_O, "\n"
		"Potential_normalize(Potential self) -> Potential\n"
		"\n"
		"Normalize the Potential (do nothing if sum is 0)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a reference to the normalized Potential\n"
		"\n"
		""},
	 { "Potential_sq", _wrap_Potential_sq, METH_O, "\n"
		"Potential_sq(Potential self) -> Potential\n"
		"\n"
		"Square all the values in the Potential\n"
		"\n"
		""},
	 { "Potential_KL", _wrap_Potential_KL, METH_VARARGS, "\n"
		"Potential_KL(Potential self, Potential p) -> double\n"
		"\n"
		"Check the compatibility and compute the Kullback-Leibler divergence between the potential and.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : pyAgrum.Potential\n"
		"  the potential from which we want to calculate the divergence.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float\n"
		"  The value of the divergence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If p is not compatible with the potential (dimension, variables)\n"
		"gum.FatalError\n"
		"  If a zero is found in p or the potential and not in the other. \n"
		"\n"
		""},
	 { "Potential_normalizeAsCPT", _wrap_Potential_normalizeAsCPT, METH_O, "\n"
		"Potential_normalizeAsCPT(Potential self)\n"
		"\n"
		"Normalize the Potential as a CPT\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a reference to the normalized Potential\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.FatalError\n"
		"  If some distribution sums to 0\n"
		"\n"
		""},
	 { "Potential_scale", _wrap_Potential_scale, METH_VARARGS, "\n"
		"Potential_scale(Potential self, double v) -> Potential\n"
		"\n"
		"Create a new potential multiplied by v.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : double\n"
		"  a multiplier\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  a reference to the modified potential\n"
		"\n"
		""},
	 { "Potential_translate", _wrap_Potential_translate, METH_VARARGS, "\n"
		"Potential_translate(Potential self, double v) -> Potential\n"
		"\n"
		"Create a new potential added with v.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : double\n"
		"  The value to be added\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  a reference to the modified potential\n"
		"\n"
		""},
	 { "Potential_draw", _wrap_Potential_draw, METH_O, "\n"
		"Potential_draw(Potential self) -> gum::Idx\n"
		"\n"
		"draw a value using the potential as a probability table.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the index of the drawn value\n"
		"\n"
		""},
	 { "Potential___add__", _wrap_Potential___add__, METH_VARARGS, "Potential___add__(Potential self, Potential p2) -> Potential"},
	 { "Potential___sub__", _wrap_Potential___sub__, METH_VARARGS, "Potential___sub__(Potential self, Potential p2) -> Potential"},
	 { "Potential___mul__", _wrap_Potential___mul__, METH_VARARGS, "Potential___mul__(Potential self, Potential p2) -> Potential"},
	 { "Potential___iadd__", _wrap_Potential___iadd__, METH_VARARGS, "Potential___iadd__(Potential self, Potential r) -> Potential"},
	 { "Potential___imul__", _wrap_Potential___imul__, METH_VARARGS, "Potential___imul__(Potential self, Potential r) -> Potential"},
	 { "Potential___isub__", _wrap_Potential___isub__, METH_VARARGS, "Potential___isub__(Potential self, Potential r) -> Potential"},
	 { "Potential___itruediv__", _wrap_Potential___itruediv__, METH_VARARGS, "Potential___itruediv__(Potential self, Potential r) -> Potential"},
	 { "Potential___repr__", _wrap_Potential___repr__, METH_O, "Potential___repr__(Potential self) -> std::string"},
	 { "Potential___str__", _wrap_Potential___str__, METH_O, "Potential___str__(Potential self) -> std::string"},
	 { "Potential_extract", _wrap_Potential_extract, METH_VARARGS, "\n"
		"Potential_extract(Potential self, Instantiation inst) -> Potential\n"
		"Potential_extract(Potential self, PyObject * dict) -> Potential\n"
		"\n"
		"create a new Potential extracted from self given a partial instantiation.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"inst : pyAgrum.instantiation\n"
		"  a partial instantiation\n"
		"dict : dict\n"
		"  a dictionnary containing discrete variables (?)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  the new Potential\n"
		"\n"
		""},
	 { "Potential_reorganize", _wrap_Potential_reorganize, METH_VARARGS, "\n"
		"Potential_reorganize(Potential self, std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > const & vars) -> Potential\n"
		"Potential_reorganize(Potential self, PyObject * varnames) -> Potential\n"
		"\n"
		"Create a new Potential with another order.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"varnames : list\n"
		"  a list of the var names in the new order\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a reference to the modified potential\n"
		"\n"
		""},
	 { "Potential_putFirst", _wrap_Potential_putFirst, METH_VARARGS, "\n"
		"Potential_putFirst(Potential self, PyObject * varname) -> Potential\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		"    The variable for which the index should be 0.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a reference to the modified potential\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the var is not in the potential \n"
		"\n"
		""},
	 { "Potential_margSumOut", _wrap_Potential_margSumOut, METH_VARARGS, "\n"
		"Potential_margSumOut(Potential self, PyObject * varnames) -> Potential\n"
		"\n"
		"Projection using sum as operation.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varnames : set\n"
		"  the set of vars to eliminate\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  the projected Potential\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument \n"
		"  If varnames contains only one variable that does not exist in the Potential\n"
		"\n"
		""},
	 { "Potential_margProdOut", _wrap_Potential_margProdOut, METH_VARARGS, "\n"
		"Potential_margProdOut(Potential self, PyObject * varnames) -> Potential\n"
		"\n"
		"Projection using multiplication as operation.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varnames : set\n"
		"  the set of vars to eliminate\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  the projected Potential\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If varnames contains only one variable that does not exist in the Potential\n"
		"\n"
		""},
	 { "Potential_margMaxOut", _wrap_Potential_margMaxOut, METH_VARARGS, "\n"
		"Potential_margMaxOut(Potential self, PyObject * varnames) -> Potential\n"
		"\n"
		"Projection using max as operation.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varnames : set\n"
		"  the set of vars to eliminate\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  the projected Potential\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If varnames contains only one variable that does not exist in the Potential\n"
		"\n"
		""},
	 { "Potential_margMinOut", _wrap_Potential_margMinOut, METH_VARARGS, "\n"
		"Potential_margMinOut(Potential self, PyObject * varnames) -> Potential\n"
		"\n"
		"Projection using min as operation.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varnames : set\n"
		"  the set of vars to eliminate\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  the projected Potential\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"InvalidArgument raised if varnames contains only one variable that does not exist in the Potential\n"
		"\n"
		""},
	 { "Potential_margSumIn", _wrap_Potential_margSumIn, METH_VARARGS, "\n"
		"Potential_margSumIn(Potential self, PyObject * varnames) -> Potential\n"
		"\n"
		"Projection using sum as operation.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varnames : set\n"
		"  the set of vars to keep\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  the projected Potential\n"
		"\n"
		""},
	 { "Potential_margProdIn", _wrap_Potential_margProdIn, METH_VARARGS, "\n"
		"Potential_margProdIn(Potential self, PyObject * varnames) -> Potential\n"
		"\n"
		"Projection using multiplication as operation.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varnames : set\n"
		"  the set of vars to keep\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  the projected Potential\n"
		"\n"
		""},
	 { "Potential_margMaxIn", _wrap_Potential_margMaxIn, METH_VARARGS, "\n"
		"Potential_margMaxIn(Potential self, PyObject * varnames) -> Potential\n"
		"\n"
		"Projection using max as operation.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varnames : set\n"
		"  the set of vars to keep\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  the projected Potential\n"
		"\n"
		""},
	 { "Potential_margMinIn", _wrap_Potential_margMinIn, METH_VARARGS, "\n"
		"Potential_margMinIn(Potential self, PyObject * varnames) -> Potential\n"
		"\n"
		"Projection using min as operation.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varnames : set\n"
		"  the set of vars to keep\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  the projected Potential\n"
		"\n"
		""},
	 { "Potential___truediv__", _wrap_Potential___truediv__, METH_VARARGS, "\n"
		"Potential___truediv__(Potential self, Potential p2) -> Potential\n"
		"Potential___truediv__(Potential self, Potential b) -> Potential\n"
		""},
	 { "Potential___div__", _wrap_Potential___div__, METH_VARARGS, "Potential___div__(Potential self, Potential b) -> Potential"},
	 { "Potential___eq__", _wrap_Potential___eq__, METH_VARARGS, "\n"
		"Potential___eq__(Potential self, Potential r) -> bool\n"
		"Potential___eq__(Potential self, Potential b) -> bool\n"
		""},
	 { "Potential___ne__", _wrap_Potential___ne__, METH_VARARGS, "\n"
		"Potential___ne__(Potential self, Potential r) -> bool\n"
		"Potential___ne__(Potential self, Potential b) -> bool\n"
		""},
	 { "Potential___fill_distrib__", _wrap_Potential___fill_distrib__, METH_O, "Potential___fill_distrib__(Potential self)"},
	 { "Potential___indexfromdict__", _wrap_Potential___indexfromdict__, METH_VARARGS, "Potential___indexfromdict__(Potential self, PyObject * id_dict) -> PyObject *"},
	 { "Potential_tolist", _wrap_Potential_tolist, METH_O, "Potential_tolist(Potential self) -> PyObject *"},
	 { "Potential_toarray", _wrap_Potential_toarray, METH_O, "Potential_toarray(Potential self) -> PyObject *"},
	 { "Potential___getitem__", _wrap_Potential___getitem__, METH_VARARGS, "Potential___getitem__(Potential self, PyObject * id)"},
	 { "Potential___setitem__", _wrap_Potential___setitem__, METH_VARARGS, "Potential___setitem__(Potential self, PyObject * id, PyObject * value)"},
	 { "Potential_var_names", _wrap_Potential_var_names, METH_O, "Potential_var_names(Potential self)"},
	 { "Potential_var_dims", _wrap_Potential_var_dims, METH_O, "Potential_var_dims(Potential self)"},
	 { "Potential_get", _wrap_Potential_get, METH_VARARGS, "\n"
		"Potential_get(Potential self, Instantiation i) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyAgrum.Instantiation\n"
		"  an Instantiation\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the value in the Potential at the position given by the instantiation\n"
		"\n"
		""},
	 { "Potential_set", _wrap_Potential_set, METH_VARARGS, "\n"
		"Potential_set(Potential self, Instantiation i, double const & value)\n"
		"\n"
		"Change the value pointed by i\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyAgrum.Instantiation\n"
		"  The Instantiation to be changed\n"
		"value : double\n"
		"  The new value of the Instantiation\n"
		"\n"
		""},
	 { "Potential_empty", _wrap_Potential_empty, METH_O, "\n"
		"Potential_empty(Potential self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    Returns true if no variable is in the potential. \n"
		"\n"
		""},
	 { "Potential_pos", _wrap_Potential_pos, METH_VARARGS, "\n"
		"Potential_pos(Potential self, DiscreteVariable v) -> gum::Idx\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		"    The variable for which the index is returned.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"    Returns the index of a variable. \n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound \n"
		"  If v is not in this multidimensional matrix. \n"
		"\n"
		""},
	 { "Potential_contains", _wrap_Potential_contains, METH_VARARGS, "\n"
		"Potential_contains(Potential self, DiscreteVariable v) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.Potential\n"
		"    a DiscreteVariable.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if the var is in the potential\n"
		"\n"
		""},
	 { "Potential_nbrDim", _wrap_Potential_nbrDim, METH_O, "\n"
		"Potential_nbrDim(Potential self) -> gum::Idx\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of vars in the multidimensional container. \n"
		"\n"
		""},
	 { "Potential_variable", _wrap_Potential_variable, METH_VARARGS, "\n"
		"Potential_variable(Potential self, gum::Idx i) -> DiscreteVariable\n"
		"Potential_variable(Potential self, std::string const & name) -> DiscreteVariable\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : int \n"
		"  An index of this multidimensional matrix.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"  the varible at the ith index \n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"  If i does not reference a variable in this multidimensional matrix. \n"
		"\n"
		""},
	 { "Potential_remove", _wrap_Potential_remove, METH_VARARGS, "\n"
		"Potential_remove(Potential self, DiscreteVariable var)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		"    The variable to be removed\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a reference to the modified potential\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"IndexError raised if the var is not in the potential \n"
		"\n"
		""},
	 { "Potential_add", _wrap_Potential_add, METH_VARARGS, "\n"
		"Potential_add(Potential self, DiscreteVariable v)\n"
		"\n"
		"Add a discrete variable to the potential.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : pyAgrum.DiscreteVariable\n"
		"  the var to be added\n"
		"\n"
		"Raises\n"
		"------\n"
		"DuplicateElement\n"
		"  If the variable is already in this Potential.\n"
		"InvalidArgument\n"
		"  If the variable is empty.\n"
		"\n"
		""},
	 { "Potential_swigregister", Potential_swigregister, METH_VARARGS, NULL},
	 { "Potential_swiginit", Potential_swiginit, METH_VARARGS, NULL},
	 { "delete_IBayesNet", _wrap_delete_IBayesNet, METH_O, "delete_IBayesNet(IBayesNet self)"},
	 { "IBayesNet_cpt", _wrap_IBayesNet_cpt, METH_VARARGS, "\n"
		"IBayesNet_cpt(IBayesNet self, gum::NodeId varId) -> Potential\n"
		"\n"
		"Returns the CPT of a variable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"VarId : int\n"
		"	A variable's id in the pyAgrum.IBayesNet.\n"
		"name : str\n"
		"	A variable's name in the pyAgrum.IBayesNet.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"	The variable's CPT. \n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound \n"
		"	If no variable's id matches varId. \n"
		"\n"
		""},
	 { "IBayesNet_variableNodeMap", _wrap_IBayesNet_variableNodeMap, METH_O, "\n"
		"IBayesNet_variableNodeMap(IBayesNet self) -> VariableNodeMap\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.variableNodeMap\n"
		"	the variable node map\n"
		"\n"
		""},
	 { "IBayesNet_variable", _wrap_IBayesNet_variable, METH_VARARGS, "\n"
		"IBayesNet_variable(IBayesNet self, gum::NodeId id) -> DiscreteVariable\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	a variable's id\n"
		"name : str\n"
		"	a variable's name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DiscreteVariable\n"
		"	the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "IBayesNet_nodeId", _wrap_IBayesNet_nodeId, METH_VARARGS, "\n"
		"IBayesNet_nodeId(IBayesNet self, DiscreteVariable var) -> gum::NodeId\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : pyAgrum.DiscreteVariable\n"
		"	a variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "IBayesNet_idFromName", _wrap_IBayesNet_idFromName, METH_VARARGS, "\n"
		"IBayesNet_idFromName(IBayesNet self, std::string const & name) -> gum::NodeId\n"
		"\n"
		"Returns a variable's id given its name in the graph.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	The variable's name from which the id is returned.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	The variable's node id.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"	If name does not match a variable in the graph\n"
		"\n"
		""},
	 { "IBayesNet_variableFromName", _wrap_IBayesNet_variableFromName, METH_VARARGS, "\n"
		"IBayesNet_variableFromName(IBayesNet self, std::string const & name) -> DiscreteVariable\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	a variable's name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DiscreteVariable\n"
		"	the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "IBayesNet_jointProbability", _wrap_IBayesNet_jointProbability, METH_VARARGS, "\n"
		"IBayesNet_jointProbability(IBayesNet self, Instantiation i) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyAgrum.instantiation\n"
		"	an instantiation of the variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	a parameter of the joint probability for the BayesNet\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"a variable not present in the instantiation is assumed to be instantiated to 0\n"
		"\n"
		""},
	 { "IBayesNet_log2JointProbability", _wrap_IBayesNet_log2JointProbability, METH_VARARGS, "\n"
		"IBayesNet_log2JointProbability(IBayesNet self, Instantiation i) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : pyAgrum.instantiation\n"
		"	an instantiation of the variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	a parameter of the log joint probability for the BayesNet\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"a variable not present in the instantiation is assumed to be instantiated to 0\n"
		"\n"
		""},
	 { "IBayesNet___eq__", _wrap_IBayesNet___eq__, METH_VARARGS, "IBayesNet___eq__(IBayesNet self, IBayesNet _from) -> bool"},
	 { "IBayesNet___ne__", _wrap_IBayesNet___ne__, METH_VARARGS, "IBayesNet___ne__(IBayesNet self, IBayesNet _from) -> bool"},
	 { "IBayesNet_dim", _wrap_IBayesNet_dim, METH_O, "\n"
		"IBayesNet_dim(IBayesNet self) -> gum::Size\n"
		"\n"
		"Returns the dimension (the number of free parameters) in this BayesNet.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the dimension of the BayesNet\n"
		"\n"
		""},
	 { "IBayesNet_maxVarDomainSize", _wrap_IBayesNet_maxVarDomainSize, METH_O, "\n"
		"IBayesNet_maxVarDomainSize(IBayesNet self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the biggest domain size among the variables of the BayesNet\n"
		"\n"
		""},
	 { "IBayesNet_minParam", _wrap_IBayesNet_minParam, METH_O, "\n"
		"IBayesNet_minParam(IBayesNet self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"    the smallest value in the CPTs of the IBayesNet\n"
		"\n"
		""},
	 { "IBayesNet_maxParam", _wrap_IBayesNet_maxParam, METH_O, "\n"
		"IBayesNet_maxParam(IBayesNet self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"    the biggest value in the CPTs of the BayesNet\n"
		"\n"
		""},
	 { "IBayesNet_minNonZeroParam", _wrap_IBayesNet_minNonZeroParam, METH_O, "\n"
		"IBayesNet_minNonZeroParam(IBayesNet self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"    the smallest value (not equal to 0) in the CPTs of the IBayesNet\n"
		"\n"
		""},
	 { "IBayesNet_maxNonOneParam", _wrap_IBayesNet_maxNonOneParam, METH_O, "\n"
		"IBayesNet_maxNonOneParam(IBayesNet self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	The biggest value (not equal to 1) in the CPTs of the BayesNet\n"
		"\n"
		""},
	 { "IBayesNet_toDot", _wrap_IBayesNet_toDot, METH_O, "\n"
		"IBayesNet_toDot(IBayesNet self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a friendly display of the graph in DOT format\n"
		"\n"
		""},
	 { "IBayesNet_nodes", _wrap_IBayesNet_nodes, METH_O, "\n"
		"IBayesNet_nodes(IBayesNet self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of ids\n"
		"\n"
		""},
	 { "IBayesNet_names", _wrap_IBayesNet_names, METH_O, "\n"
		"IBayesNet_names(IBayesNet self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	The names of the graph variables\n"
		"\n"
		""},
	 { "IBayesNet_minimalCondSet", _wrap_IBayesNet_minimalCondSet, METH_VARARGS, "\n"
		"IBayesNet_minimalCondSet(IBayesNet self, gum::NodeId target, gum::NodeSet const & soids) -> gum::NodeSet\n"
		"IBayesNet_minimalCondSet(IBayesNet self, gum::NodeSet const & targets, gum::NodeSet const & soids) -> gum::NodeSet\n"
		"IBayesNet_minimalCondSet(IBayesNet self, gum::NodeId target, PyObject * list) -> PyObject\n"
		"IBayesNet_minimalCondSet(IBayesNet self, PyObject * targets, PyObject * list) -> PyObject *\n"
		"\n"
		"Returns, given one or many targets and a list of variables, the minimal set of those needed to calculate the target/targets.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"	The id of the target\n"
		"targets : list\n"
		"	The ids of the targets\n"
		"list : list\n"
		"	The list of available variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"	The minimal set of variables\n"
		"\n"
		""},
	 { "IBayesNet___repr__", _wrap_IBayesNet___repr__, METH_O, "IBayesNet___repr__(IBayesNet self) -> std::string"},
	 { "IBayesNet___str__", _wrap_IBayesNet___str__, METH_O, "IBayesNet___str__(IBayesNet self) -> std::string"},
	 { "IBayesNet_arcs", _wrap_IBayesNet_arcs, METH_O, "\n"
		"IBayesNet_arcs(IBayesNet self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	The lisf of arcs in the IBayesNet\n"
		"\n"
		""},
	 { "IBayesNet_parents", _wrap_IBayesNet_parents, METH_VARARGS, "\n"
		"IBayesNet_parents(IBayesNet self, gum::NodeId id) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id :\n"
		"	The id of the child node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"    the set of the parents ids.\n"
		"\n"
		""},
	 { "IBayesNet_children", _wrap_IBayesNet_children, METH_VARARGS, "\n"
		"IBayesNet_children(IBayesNet self, gum::NodeId id) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  the id of the parent\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"	the set of all the children\n"
		"\n"
		""},
	 { "IBayesNet_swigregister", IBayesNet_swigregister, METH_VARARGS, NULL},
	 { "BayesNet_fastPrototype", _wrap_BayesNet_fastPrototype, METH_VARARGS, "\n"
		"BayesNet_fastPrototype(std::string const & dotlike, gum::Size domainSize=2) -> BayesNet\n"
		"\n"
		"Create a bn with a dotlike syntax : 'a->b->c;b->d;'.\n"
		"\n"
		"The domain size maybe specified using 'a[10]'.\n"
		"\n"
		"Note that if the dotlike string contains such a specification for an already defined variable, the first specification will be used.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dotlike : str\n"
		"	the string containing the specification\n"
		"domainSize : int\n"
		"	the default domain size for variables\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.BayesNet\n"
		"	the resulting bayesian network \n"
		"\n"
		""},
	 { "delete_BayesNet", _wrap_delete_BayesNet, METH_O, "delete_BayesNet(BayesNet self)"},
	 { "new_BayesNet", _wrap_new_BayesNet, METH_VARARGS, "\n"
		"BayesNet()\n"
		"BayesNet(std::string name)\n"
		"new_BayesNet(BayesNet source) -> BayesNet\n"
		""},
	 { "BayesNet_cpt", _wrap_BayesNet_cpt, METH_VARARGS, "\n"
		"BayesNet_cpt(BayesNet self, gum::NodeId varId) -> Potential\n"
		"BayesNet_cpt(BayesNet self, std::string const & name) -> Potential\n"
		"\n"
		"Returns the CPT of a variable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"VarId : int\n"
		"	A variable's id in the pyAgrum.BayesNet.\n"
		"name : str\n"
		"	A variable's name in the pyAgrum.BayesNet.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"	The variable's CPT. \n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"    If no variable's id matches varId.\n"
		"\n"
		""},
	 { "BayesNet_variableNodeMap", _wrap_BayesNet_variableNodeMap, METH_O, "\n"
		"BayesNet_variableNodeMap(BayesNet self) -> VariableNodeMap\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.variableNodeMap\n"
		"	the variable node map\n"
		"\n"
		""},
	 { "BayesNet_add", _wrap_BayesNet_add, METH_VARARGS, "\n"
		"BayesNet_add(BayesNet self, DiscreteVariable var) -> gum::NodeId\n"
		"BayesNet_add(BayesNet self, std::string const & name, unsigned int nbrmod) -> gum::NodeId\n"
		"BayesNet_add(BayesNet self, DiscreteVariable var, gum::MultiDimImplementation< double > * aContent) -> gum::NodeId\n"
		"BayesNet_add(BayesNet self, DiscreteVariable var, gum::NodeId id) -> gum::NodeId\n"
		"BayesNet_add(BayesNet self, DiscreteVariable var, gum::MultiDimImplementation< double > * aContent, gum::NodeId id) -> gum::NodeId\n"
		"\n"
		"Add a variable to the pyAgrum.BayesNet. \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	the variable added\n"
		"name : str \n"
		"	the variable name\n"
		"nbrmod : int\n"
		"	the numbre of modalities for the new variable\n"
		"id : int\n"
		"	the variable forced id in the pyAgrum.BayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int \n"
		"	the id of the new node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.DuplicateLabel\n"
		"    If variable.name() is already used in this pyAgrum.BayesNet.\n"
		"gum.NotAllowed\n"
		"    If nbrmod<2\n"
		"gum.DuplicateElement\n"
		"    If id is already used.\n"
		"\n"
		""},
	 { "BayesNet_erase", _wrap_BayesNet_erase, METH_VARARGS, "\n"
		"BayesNet_erase(BayesNet self, gum::NodeId varId)\n"
		"BayesNet_erase(BayesNet self, std::string const & name)\n"
		"BayesNet_erase(BayesNet self, DiscreteVariable var)\n"
		"\n"
		"Remove a variable from the gum::BayesNet.\n"
		"\n"
		"Removes the corresponding variable from the gum::BayesNet and from all of it's children gum::Potential.\n"
		"\n"
		"If no variable matches the given id, then nothing is done.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	The variable's id to remove. \n"
		"name : str\n"
		"	The variable's name to remove.\n"
		"var : pyAgrum.DiscreteVariable\n"
		"	A reference on the variable to remove. \n"
		"\n"
		""},
	 { "BayesNet_variable", _wrap_BayesNet_variable, METH_VARARGS, "\n"
		"BayesNet_variable(BayesNet self, gum::NodeId id) -> DiscreteVariable\n"
		"BayesNet_variable(BayesNet self, std::string const & name) -> DiscreteVariable\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	a variable's id\n"
		"name : str\n"
		"	a variable's name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DiscreteVariable\n"
		"	the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "BayesNet_changeVariableName", _wrap_BayesNet_changeVariableName, METH_VARARGS, "\n"
		"BayesNet_changeVariableName(BayesNet self, gum::NodeId id, std::string const & new_name)\n"
		"BayesNet_changeVariableName(BayesNet self, std::string const & name, std::string const & new_name)\n"
		"\n"
		"Changes a variable's name in the gum::BayesNet.\n"
		"\n"
		"This will change the gum::DiscreteVariable names in the gum::BayesNet.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"new_name : str\n"
		"	the new name of the variable\n"
		"NodeId : int\n"
		"	the id of the node\n"
		"name : str\n"
		"	the name of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.DuplicateLabel\n"
		"    If new_name is already used in this BayesNet.\n"
		"gum.NotFound\n"
		"    If no variable matches id.\n"
		"\n"
		""},
	 { "BayesNet_changeVariableLabel", _wrap_BayesNet_changeVariableLabel, METH_VARARGS, "\n"
		"BayesNet_changeVariableLabel(BayesNet self, gum::NodeId id, std::string const & old_label, std::string const & new_label)\n"
		"BayesNet_changeVariableLabel(BayesNet self, std::string const & name, std::string const & old_label, std::string const & new_label)\n"
		"\n"
		"change the label of the variable associated to nodeId to the new value.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	the id of the node\n"
		"name : str\n"
		"	the name of the variable\n"
		"old_label : str\n"
		"	the new label\n"
		"new_label : str\n"
		"	the new label\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"    if id/name is not a variable or if old_label does not exist.\n"
		"\n"
		""},
	 { "BayesNet_nodeId", _wrap_BayesNet_nodeId, METH_VARARGS, "\n"
		"BayesNet_nodeId(BayesNet self, DiscreteVariable var) -> gum::NodeId\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : pyAgrum.DiscreteVariable\n"
		"	a variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "BayesNet_idFromName", _wrap_BayesNet_idFromName, METH_VARARGS, "\n"
		"BayesNet_idFromName(BayesNet self, std::string const & name) -> gum::NodeId\n"
		"\n"
		"Returns a variable's id given its name in the graph.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	The variable's name from which the id is returned.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int :\n"
		"	The variable's node id.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"	If name does not match a variable in the graph\n"
		"\n"
		""},
	 { "BayesNet_variableFromName", _wrap_BayesNet_variableFromName, METH_VARARGS, "\n"
		"BayesNet_variableFromName(BayesNet self, std::string const & name) -> DiscreteVariable\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	a variable's name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DiscreteVariable\n"
		"	the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the graph does not contain the variable\n"
		"\n"
		""},
	 { "BayesNet_addArc", _wrap_BayesNet_addArc, METH_VARARGS, "\n"
		"BayesNet_addArc(BayesNet self, gum::NodeId tail, gum::NodeId head)\n"
		"BayesNet_addArc(BayesNet self, std::string const & tail, std::string const & head)\n"
		"\n"
		"Add an arc in the BN, and update arc.head's CPT.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"head :\n"
		"	a variable's id (int)\n"
		"tail :\n"
		"	a variable's id (int)\n"
		"head :\n"
		"	a variable's name (str)\n"
		"tail :\n"
		"	a variable's name (str)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidEdge\n"
		"    If arc.tail and/or arc.head are not in the BN.\n"
		"\n"
		""},
	 { "BayesNet_eraseArc", _wrap_BayesNet_eraseArc, METH_VARARGS, "\n"
		"BayesNet_eraseArc(BayesNet self, Arc arc)\n"
		"BayesNet_eraseArc(BayesNet self, gum::NodeId tail, gum::NodeId head)\n"
		"BayesNet_eraseArc(BayesNet self, std::string const & tail, std::string const & head)\n"
		"\n"
		"Removes an arc in the BN, and update head's CTP.\n"
		"\n"
		"If (tail, head) doesn't exist, the nothing happens.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arc : pyAgrum.Arc \n"
		"	The arc to be removed.\n"
		"head :\n"
		"	a variable's id (int)\n"
		"tail :\n"
		"	a variable's id (int)\n"
		"head :\n"
		"	a variable's name (str)\n"
		"tail :\n"
		"	a variable's name (str)\n"
		"\n"
		""},
	 { "BayesNet_beginTopologyTransformation", _wrap_BayesNet_beginTopologyTransformation, METH_O, "\n"
		"BayesNet_beginTopologyTransformation(BayesNet self)\n"
		"\n"
		"When inserting/removing arcs, node CPTs change their dimension with a cost in time.\n"
		"begin Multiple Change for all CPTs\n"
		"These functions delay the CPTs change to be done just once at the end of a sequence of topology modification, begins a sequence of insertions/deletions of arcs without changing the dimensions of the CPTs.\n"
		"\n"
		""},
	 { "BayesNet_endTopologyTransformation", _wrap_BayesNet_endTopologyTransformation, METH_O, "\n"
		"BayesNet_endTopologyTransformation(BayesNet self)\n"
		"\n"
		"Terminates a sequence of insertions/deletions of arcs by adjusting all CPTs dimensions.\n"
		"End Multiple Change for all CPTs.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.BayesNet\n"
		"\n"
		""},
	 { "BayesNet_reverseArc", _wrap_BayesNet_reverseArc, METH_VARARGS, "\n"
		"BayesNet_reverseArc(BayesNet self, gum::NodeId tail, gum::NodeId head)\n"
		"BayesNet_reverseArc(BayesNet self, std::string const & tail, std::string const & head)\n"
		"BayesNet_reverseArc(BayesNet self, Arc arc)\n"
		"\n"
		"Reverses an arc while preserving the same joint distribution. \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tail\n"
		"	(int) the id of the tail variable\n"
		"head\n"
		"	(int) the id of the head variable\n"
		"tail\n"
		"	(str) the name of the tail variable\n"
		"head\n"
		"	(str) the name of the head variable\n"
		"arc : pyAgrum.Arc\n"
		"	an arc \n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArc\n"
		"    If the arc does not exsit or if its reversal would induce a directed cycle.\n"
		"\n"
		""},
	 { "BayesNet_addNoisyOR", _wrap_BayesNet_addNoisyOR, METH_VARARGS, "\n"
		"BayesNet_addNoisyOR(BayesNet self, DiscreteVariable var, double external_weight) -> gum::NodeId\n"
		"BayesNet_addNoisyOR(BayesNet self, DiscreteVariable var, double external_weight, gum::NodeId id) -> gum::NodeId\n"
		"\n"
		"Add a variable, it's associate node and a noisyOR implementation.\n"
		"\n"
		"Since it seems that the 'classical' noisyOR is the Compound noisyOR, we keep the addNoisyOR as an alias for addNoisyORCompound.\n"
		"\n"
		"(The id of the new variable can be automatically generated.)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	The variable added by copy\n"
		"externalWeight : double\n"
		"	the added external weight\n"
		"id : int\n"
		"	The proposed id for the variable.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the added variable. \n"
		"\n"
		"Raises\n"
		"--------\n"
		"gum.DuplicateElement\n"
		"    If id is already used\n"
		"\n"
		""},
	 { "BayesNet_addNoisyORNet", _wrap_BayesNet_addNoisyORNet, METH_VARARGS, "\n"
		"BayesNet_addNoisyORNet(BayesNet self, DiscreteVariable var, double external_weight) -> gum::NodeId\n"
		"BayesNet_addNoisyORNet(BayesNet self, DiscreteVariable var, double external_weight, gum::NodeId id) -> gum::NodeId\n"
		"\n"
		"Add a variable, its associate node and a noisyOR implementation.\n"
		"\n"
		"Since it seems that the 'classical' noisyOR is the Compound noisyOR, we keep the addNoisyOR as an alias for addNoisyORCompound.\n"
		"\n"
		"(The id of the new variable can be automatically generated.)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	The variable added by copy\n"
		"externalWeight : double\n"
		"	the added external weight\n"
		"id : int\n"
		"	The proposed id for the variable.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the added variable.\n"
		"\n"
		""},
	 { "BayesNet_addNoisyORCompound", _wrap_BayesNet_addNoisyORCompound, METH_VARARGS, "\n"
		"BayesNet_addNoisyORCompound(BayesNet self, DiscreteVariable var, double external_weight) -> gum::NodeId\n"
		"BayesNet_addNoisyORCompound(BayesNet self, DiscreteVariable var, double external_weight, gum::NodeId id) -> gum::NodeId\n"
		"\n"
		"Add a variable, it's associate node and a noisyOR implementation.\n"
		"\n"
		"Since it seems that the 'classical' noisyOR is the Compound noisyOR, we keep the addNoisyOR as an alias for addNoisyORCompound.\n"
		"\n"
		"(The id of the new variable can be automatically generated.)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	The variable added by copy\n"
		"externalWeight : double\n"
		"	the added external weight\n"
		"id : int\n"
		"	The proposed id for the variable.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the added variable.\n"
		"\n"
		"Raises\n"
		"--------\n"
		"gum.DuplicateElement\n"
		"    If id is already used\n"
		"\n"
		""},
	 { "BayesNet_addNoisyAND", _wrap_BayesNet_addNoisyAND, METH_VARARGS, "\n"
		"BayesNet_addNoisyAND(BayesNet self, DiscreteVariable var, double external_weight, gum::NodeId id) -> gum::NodeId\n"
		"BayesNet_addNoisyAND(BayesNet self, DiscreteVariable var, double external_weight) -> gum::NodeId\n"
		"\n"
		"Add a variable, its associate node and a noisyAND implementation.\n"
		"\n"
		"(The id of the new variable can be automatically generated.)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	The variable added by copy\n"
		"externalWeight : double\n"
		"	the added external weight\n"
		"id : int\n"
		"	The proposed id for the variable.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the added variable.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.DuplicateElement\n"
		"    If id is already used\n"
		"\n"
		""},
	 { "BayesNet_addLogit", _wrap_BayesNet_addLogit, METH_VARARGS, "\n"
		"BayesNet_addLogit(BayesNet self, DiscreteVariable var, double external_weight, gum::NodeId id) -> gum::NodeId\n"
		"BayesNet_addLogit(BayesNet self, DiscreteVariable var, double external_weight) -> gum::NodeId\n"
		"\n"
		"Add a variable, its associate node and a Logit implementation.\n"
		"\n"
		"(The id of the new variable can be automatically generated.)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	The variable added by copy\n"
		"externalWeight : double\n"
		"	the added external weight\n"
		"id : int\n"
		"	The proposed id for the variable.\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the added variable.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.DuplicateElement\n"
		"    If id is already used\n"
		"\n"
		""},
	 { "BayesNet_addOR", _wrap_BayesNet_addOR, METH_VARARGS, "\n"
		"BayesNet_addOR(BayesNet self, DiscreteVariable var) -> gum::NodeId\n"
		"\n"
		"Add a variable, it's associate node and an OR implementation.\n"
		"\n"
		"The id of the new variable is automatically generated.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"	If parents are not boolean, all value>1 is True\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	The variable added by copy\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the added variable.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.SizeError\n"
		"    If variable.domainSize()>2\n"
		"\n"
		""},
	 { "BayesNet_addAND", _wrap_BayesNet_addAND, METH_VARARGS, "\n"
		"BayesNet_addAND(BayesNet self, DiscreteVariable var) -> gum::NodeId\n"
		"\n"
		"Add a variable, it's associate node and an AND implementation.\n"
		"\n"
		"The id of the new variable is automatically generated.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	The variable added by copy.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the added variable. \n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.SizeError\n"
		"    If variable.domainSize()>2\n"
		"\n"
		""},
	 { "BayesNet_addAMPLITUDE", _wrap_BayesNet_addAMPLITUDE, METH_VARARGS, "\n"
		"BayesNet_addAMPLITUDE(BayesNet self, DiscreteVariable var) -> gum::NodeId\n"
		"\n"
		"Others aggregators\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	the variable to be added\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the added value\n"
		"\n"
		""},
	 { "BayesNet_addCOUNT", _wrap_BayesNet_addCOUNT, METH_VARARGS, "\n"
		"BayesNet_addCOUNT(BayesNet self, DiscreteVariable var, gum::Idx value=1) -> gum::NodeId\n"
		"\n"
		"Others aggregators\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	the variable to be added\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the added value\n"
		"\n"
		""},
	 { "BayesNet_addEXISTS", _wrap_BayesNet_addEXISTS, METH_VARARGS, "\n"
		"BayesNet_addEXISTS(BayesNet self, DiscreteVariable var, gum::Idx value=1) -> gum::NodeId\n"
		"\n"
		"Others aggregators\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	the variable to be added\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the added value\n"
		"\n"
		""},
	 { "BayesNet_addFORALL", _wrap_BayesNet_addFORALL, METH_VARARGS, "\n"
		"BayesNet_addFORALL(BayesNet self, DiscreteVariable var, gum::Idx value=1) -> gum::NodeId\n"
		"\n"
		"Others aggregators\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	the variable to be added\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the added variable.\n"
		"\n"
		""},
	 { "BayesNet_addMAX", _wrap_BayesNet_addMAX, METH_VARARGS, "\n"
		"BayesNet_addMAX(BayesNet self, DiscreteVariable var) -> gum::NodeId\n"
		"\n"
		"Others aggregators\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	the variable to be added\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the added value\n"
		"\n"
		""},
	 { "BayesNet_addMEDIAN", _wrap_BayesNet_addMEDIAN, METH_VARARGS, "\n"
		"BayesNet_addMEDIAN(BayesNet self, DiscreteVariable var) -> gum::NodeId\n"
		"\n"
		"Others aggregators\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	the variable to be added\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the added value\n"
		"\n"
		""},
	 { "BayesNet_addMIN", _wrap_BayesNet_addMIN, METH_VARARGS, "\n"
		"BayesNet_addMIN(BayesNet self, DiscreteVariable var) -> gum::NodeId\n"
		"\n"
		"Others aggregators\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	the variable to be added\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the added value\n"
		"\n"
		""},
	 { "BayesNet_addWeightedArc", _wrap_BayesNet_addWeightedArc, METH_VARARGS, "\n"
		"BayesNet_addWeightedArc(BayesNet self, gum::NodeId tail, gum::NodeId head, double causalWeight)\n"
		"BayesNet_addWeightedArc(BayesNet self, std::string const & tail, std::string const & head, double causalWeight)\n"
		"\n"
		"Add an arc in the BN, and update arc.head's CPT.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"head :\n"
		"	a variable's id (int)\n"
		"tail :\n"
		"	a variable's id (int)\n"
		"head :\n"
		"	a variable's name (str)\n"
		"tail :\n"
		"	a variable's name (str)\n"
		"causalWeight : double\n"
		"	the added causal weight\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArc\n"
		"    If arc.tail and/or arc.head are not in the BN.\n"
		"gum.InvalidArc\n"
		"    If variable in arc.head is not a NoisyOR variable.\n"
		"\n"
		""},
	 { "BayesNet_generateCPTs", _wrap_BayesNet_generateCPTs, METH_O, "\n"
		"BayesNet_generateCPTs(BayesNet self)\n"
		"\n"
		"Randomly generates CPTs for a given structure.\n"
		"\n"
		""},
	 { "BayesNet_generateCPT", _wrap_BayesNet_generateCPT, METH_VARARGS, "\n"
		"BayesNet_generateCPT(BayesNet self, gum::NodeId node)\n"
		"BayesNet_generateCPT(BayesNet self, std::string const & name)\n"
		"\n"
		"Randomly generate CPT for a given node in a given structure.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"node : int\n"
		"	The variable's id.\n"
		"name : str \n"
		"	The variable's name.\n"
		"\n"
		""},
	 { "BayesNet_changePotential", _wrap_BayesNet_changePotential, METH_VARARGS, "\n"
		"BayesNet_changePotential(BayesNet self, gum::NodeId id, Potential newPot)\n"
		"BayesNet_changePotential(BayesNet self, std::string const & name, Potential newPot)\n"
		"\n"
		"change the CPT associated to nodeId to newPot delete the old CPT associated to nodeId.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"newPot : pyAgrum.Potential\n"
		"	the new potential\n"
		"NodeId : int\n"
		"	the id of the node\n"
		"name : str\n"
		"	the name of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotAllowed\n"
		"    If newPot has not the same signature as __probaMap[NodeId]\n"
		"\n"
		""},
	 { "BayesNet_dag", _wrap_BayesNet_dag, METH_O, "\n"
		"BayesNet_dag(BayesNet self) -> DAG\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DAG\n"
		"	a constant reference to the dag of this BayesNet.\n"
		"\n"
		""},
	 { "BayesNet_size", _wrap_BayesNet_size, METH_O, "\n"
		"BayesNet_size(BayesNet self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the number of nodes in the graph\n"
		"\n"
		""},
	 { "BayesNet_nodes", _wrap_BayesNet_nodes, METH_O, "\n"
		"BayesNet_nodes(BayesNet self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of ids\n"
		"\n"
		""},
	 { "BayesNet_log10DomainSize", _wrap_BayesNet_log10DomainSize, METH_O, "\n"
		"BayesNet_log10DomainSize(BayesNet self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	The log10 domain size of the joint probability for the model.\n"
		"\n"
		""},
	 { "BayesNet_loadBIF", _wrap_BayesNet_loadBIF, METH_VARARGS, "\n"
		"BayesNet_loadBIF(BayesNet self, std::string name, PyObject * l=(PyObject *) 0) -> std::string\n"
		"\n"
		"Load a BIF file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"l : list\n"
		"	list of functions to execute\n"
		"\n"
		"Raises\n"
		"--------\n"
		"gum.IOError\n"
		"    If file not found\n"
		"gum.FatalError\n"
		"    If file is not valid\n"
		"\n"
		""},
	 { "BayesNet_saveBIF", _wrap_BayesNet_saveBIF, METH_VARARGS, "\n"
		"BayesNet_saveBIF(BayesNet self, std::string name)\n"
		"\n"
		"Save the BayesNet in a BIF file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"\n"
		""},
	 { "BayesNet_loadDSL", _wrap_BayesNet_loadDSL, METH_VARARGS, "\n"
		"BayesNet_loadDSL(BayesNet self, std::string name, PyObject * l=(PyObject *) 0) -> std::string\n"
		"\n"
		"Load a DSL file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"l : list\n"
		"	list of functions to execute\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IOError\n"
		"    If file not found\n"
		"gum.FatalError\n"
		"    If file is not valid\n"
		"\n"
		""},
	 { "BayesNet_saveDSL", _wrap_BayesNet_saveDSL, METH_VARARGS, "\n"
		"BayesNet_saveDSL(BayesNet self, std::string name)\n"
		"\n"
		"Save the BayesNet in a DSL file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"\n"
		""},
	 { "BayesNet_loadNET", _wrap_BayesNet_loadNET, METH_VARARGS, "\n"
		"BayesNet_loadNET(BayesNet self, std::string name, PyObject * l=(PyObject *) 0) -> std::string\n"
		"\n"
		"Load a NET file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the name's file\n"
		"l : list\n"
		"	list of functions to execute\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IOError\n"
		"    If file not found\n"
		"gum.FatalError\n"
		"    If file is not valid\n"
		"\n"
		""},
	 { "BayesNet_saveNET", _wrap_BayesNet_saveNET, METH_VARARGS, "\n"
		"BayesNet_saveNET(BayesNet self, std::string name)\n"
		"\n"
		"Save the BayesNet in a NET file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"\n"
		""},
	 { "BayesNet_loadO3PRM", _wrap_BayesNet_loadO3PRM, METH_VARARGS, "\n"
		"BayesNet_loadO3PRM(BayesNet self, std::string name, std::string system=\"\", std::string classpath=\"\", PyObject * l=(PyObject *) 0) -> std::string\n"
		"\n"
		"Load an O3PRM file.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"The O3PRM language is the only language allowing to manipulate not only DiscretizedVariable but also RangeVariable and LabelizedVariable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"system : str\n"
		"	the system's name\n"
		"classpath : str\n"
		"	the classpath\n"
		"l : list\n"
		"	list of functions to execute\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IOError\n"
		"    If file not found\n"
		"gum.FatalError\n"
		"    If file is not valid\n"
		"\n"
		""},
	 { "BayesNet_saveO3PRM", _wrap_BayesNet_saveO3PRM, METH_VARARGS, "\n"
		"BayesNet_saveO3PRM(BayesNet self, std::string name)\n"
		"\n"
		"Save the BayesNet in an O3PRM file.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"The O3PRM language is the only language allowing to manipulate not only DiscretizedVariable but also RangeVariable and LabelizedVariable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"\n"
		""},
	 { "BayesNet_loadBIFXML", _wrap_BayesNet_loadBIFXML, METH_VARARGS, "\n"
		"BayesNet_loadBIFXML(BayesNet self, std::string name, PyObject * l=(PyObject *) 0) -> std::string\n"
		"\n"
		"Load a BIFXML file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the name's file\n"
		"l : list\n"
		"	list of functions to execute\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IOError\n"
		"    If file not found\n"
		"gum.FatalError\n"
		"    If file is not valid\n"
		"\n"
		""},
	 { "BayesNet_saveBIFXML", _wrap_BayesNet_saveBIFXML, METH_VARARGS, "\n"
		"BayesNet_saveBIFXML(BayesNet self, std::string name)\n"
		"\n"
		"Save the BayesNet in a BIFXML file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"\n"
		""},
	 { "BayesNet_loadUAI", _wrap_BayesNet_loadUAI, METH_VARARGS, "\n"
		"BayesNet_loadUAI(BayesNet self, std::string name, PyObject * l=(PyObject *) 0) -> std::string\n"
		"\n"
		"Load an UAI file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the name's file\n"
		"l : list\n"
		"	list of functions to execute\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IOError\n"
		"    If file not found\n"
		"gum.FatalError\n"
		"    If file is not valid\n"
		"\n"
		""},
	 { "BayesNet_saveUAI", _wrap_BayesNet_saveUAI, METH_VARARGS, "\n"
		"BayesNet_saveUAI(BayesNet self, std::string name)\n"
		"\n"
		"Save the BayesNet in an UAI file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"\n"
		""},
	 { "BayesNet___repr__", _wrap_BayesNet___repr__, METH_O, "BayesNet___repr__(BayesNet self) -> std::string"},
	 { "BayesNet___str__", _wrap_BayesNet___str__, METH_O, "BayesNet___str__(BayesNet self) -> std::string"},
	 { "BayesNet_swigregister", BayesNet_swigregister, METH_VARARGS, NULL},
	 { "BayesNet_swiginit", BayesNet_swiginit, METH_VARARGS, NULL},
	 { "delete_BayesNetInference", _wrap_delete_BayesNetInference, METH_O, "delete_BayesNetInference(BayesNetInference self)"},
	 { "BayesNetInference_setBN", _wrap_BayesNetInference_setBN, METH_VARARGS, "BayesNetInference_setBN(BayesNetInference self, IBayesNet bn)"},
	 { "BayesNetInference_BN", _wrap_BayesNetInference_BN, METH_O, "BayesNetInference_BN(BayesNetInference self) -> IBayesNet"},
	 { "BayesNetInference_domainSizes", _wrap_BayesNetInference_domainSizes, METH_O, "BayesNetInference_domainSizes(BayesNetInference self) -> gum::NodeProperty< gum::Size > const &"},
	 { "BayesNetInference_isInferenceReady", _wrap_BayesNetInference_isInferenceReady, METH_O, "BayesNetInference_isInferenceReady(BayesNetInference self) -> bool"},
	 { "BayesNetInference_isInferenceOutdatedBNStructure", _wrap_BayesNetInference_isInferenceOutdatedBNStructure, METH_O, "BayesNetInference_isInferenceOutdatedBNStructure(BayesNetInference self) -> bool"},
	 { "BayesNetInference_isInferenceOutdatedBNPotentials", _wrap_BayesNetInference_isInferenceOutdatedBNPotentials, METH_O, "BayesNetInference_isInferenceOutdatedBNPotentials(BayesNetInference self) -> bool"},
	 { "BayesNetInference_isInferenceDone", _wrap_BayesNetInference_isInferenceDone, METH_O, "BayesNetInference_isInferenceDone(BayesNetInference self) -> bool"},
	 { "BayesNetInference_isDone", _wrap_BayesNetInference_isDone, METH_O, "BayesNetInference_isDone(BayesNetInference self) -> bool"},
	 { "BayesNetInference_prepareInference", _wrap_BayesNetInference_prepareInference, METH_O, "BayesNetInference_prepareInference(BayesNetInference self)"},
	 { "BayesNetInference_makeInference", _wrap_BayesNetInference_makeInference, METH_O, "BayesNetInference_makeInference(BayesNetInference self)"},
	 { "BayesNetInference_clear", _wrap_BayesNetInference_clear, METH_O, "BayesNetInference_clear(BayesNetInference self)"},
	 { "BayesNetInference_state", _wrap_BayesNetInference_state, METH_O, "BayesNetInference_state(BayesNetInference self) -> gum::BayesNetInference< double >::StateOfInference"},
	 { "BayesNetInference_addEvidence", _wrap_BayesNetInference_addEvidence, METH_VARARGS, "\n"
		"BayesNetInference_addEvidence(BayesNetInference self, gum::NodeId id, gum::Idx const val)\n"
		"BayesNetInference_addEvidence(BayesNetInference self, std::string const & nodeName, gum::Idx const val)\n"
		"BayesNetInference_addEvidence(BayesNetInference self, gum::NodeId id, std::string const & label)\n"
		"BayesNetInference_addEvidence(BayesNetInference self, std::string const & nodeName, std::string const & label)\n"
		"BayesNetInference_addEvidence(BayesNetInference self, gum::NodeId id, Vector vals)\n"
		"BayesNetInference_addEvidence(BayesNetInference self, std::string const & nodeName, Vector vals)\n"
		"BayesNetInference_addEvidence(BayesNetInference self, Potential pot)\n"
		"BayesNetInference_addEvidence(BayesNetInference self, Potential pot)\n"
		""},
	 { "BayesNetInference_addSetOfEvidence", _wrap_BayesNetInference_addSetOfEvidence, METH_VARARGS, "BayesNetInference_addSetOfEvidence(BayesNetInference self, gum::Set< gum::Potential< double > const * > const & potset)"},
	 { "BayesNetInference_addListOfEvidence", _wrap_BayesNetInference_addListOfEvidence, METH_VARARGS, "BayesNetInference_addListOfEvidence(BayesNetInference self, gum::List< gum::Potential< double > const * > const & potlist)"},
	 { "BayesNetInference_chgEvidence", _wrap_BayesNetInference_chgEvidence, METH_VARARGS, "\n"
		"BayesNetInference_chgEvidence(BayesNetInference self, gum::NodeId id, gum::Idx const val)\n"
		"BayesNetInference_chgEvidence(BayesNetInference self, std::string const & nodeName, gum::Idx const val)\n"
		"BayesNetInference_chgEvidence(BayesNetInference self, gum::NodeId id, std::string const & label)\n"
		"BayesNetInference_chgEvidence(BayesNetInference self, std::string const & nodeName, std::string const & label)\n"
		"BayesNetInference_chgEvidence(BayesNetInference self, gum::NodeId id, Vector vals)\n"
		"BayesNetInference_chgEvidence(BayesNetInference self, std::string const & nodeName, Vector vals)\n"
		"BayesNetInference_chgEvidence(BayesNetInference self, Potential pot)\n"
		""},
	 { "BayesNetInference_eraseAllEvidence", _wrap_BayesNetInference_eraseAllEvidence, METH_O, "BayesNetInference_eraseAllEvidence(BayesNetInference self)"},
	 { "BayesNetInference_eraseEvidence", _wrap_BayesNetInference_eraseEvidence, METH_VARARGS, "\n"
		"BayesNetInference_eraseEvidence(BayesNetInference self, gum::NodeId id)\n"
		"BayesNetInference_eraseEvidence(BayesNetInference self, std::string const & nodeName)\n"
		""},
	 { "BayesNetInference_hasEvidence", _wrap_BayesNetInference_hasEvidence, METH_VARARGS, "\n"
		"BayesNetInference_hasEvidence(BayesNetInference self) -> bool\n"
		"BayesNetInference_hasEvidence(BayesNetInference self, gum::NodeId id) -> bool\n"
		"BayesNetInference_hasEvidence(BayesNetInference self, std::string const & nodeName) -> bool\n"
		""},
	 { "BayesNetInference_hasHardEvidence", _wrap_BayesNetInference_hasHardEvidence, METH_VARARGS, "\n"
		"BayesNetInference_hasHardEvidence(BayesNetInference self, gum::NodeId id) -> bool\n"
		"BayesNetInference_hasHardEvidence(BayesNetInference self, std::string const & nodeName) -> bool\n"
		""},
	 { "BayesNetInference_hasSoftEvidence", _wrap_BayesNetInference_hasSoftEvidence, METH_VARARGS, "\n"
		"BayesNetInference_hasSoftEvidence(BayesNetInference self, gum::NodeId id) -> bool\n"
		"BayesNetInference_hasSoftEvidence(BayesNetInference self, std::string const & nodeName) -> bool\n"
		""},
	 { "BayesNetInference_nbrEvidence", _wrap_BayesNetInference_nbrEvidence, METH_O, "BayesNetInference_nbrEvidence(BayesNetInference self) -> gum::Size"},
	 { "BayesNetInference_nbrHardEvidence", _wrap_BayesNetInference_nbrHardEvidence, METH_O, "BayesNetInference_nbrHardEvidence(BayesNetInference self) -> gum::Size"},
	 { "BayesNetInference_nbrSoftEvidence", _wrap_BayesNetInference_nbrSoftEvidence, METH_O, "BayesNetInference_nbrSoftEvidence(BayesNetInference self) -> gum::Size"},
	 { "BayesNetInference_evidence", _wrap_BayesNetInference_evidence, METH_O, "BayesNetInference_evidence(BayesNetInference self) -> gum::NodeProperty< gum::Potential< double > const * > const &"},
	 { "BayesNetInference_softEvidenceNodes", _wrap_BayesNetInference_softEvidenceNodes, METH_O, "BayesNetInference_softEvidenceNodes(BayesNetInference self) -> gum::NodeSet const &"},
	 { "BayesNetInference_hardEvidenceNodes", _wrap_BayesNetInference_hardEvidenceNodes, METH_O, "BayesNetInference_hardEvidenceNodes(BayesNetInference self) -> gum::NodeSet const &"},
	 { "BayesNetInference_hardEvidence", _wrap_BayesNetInference_hardEvidence, METH_O, "BayesNetInference_hardEvidence(BayesNetInference self) -> gum::NodeProperty< gum::Idx > const &"},
	 { "BayesNetInference_swigregister", BayesNetInference_swigregister, METH_VARARGS, NULL},
	 { "new_LazyPropagation", _wrap_new_LazyPropagation, METH_VARARGS, "LazyPropagation(IBayesNet BN, gum::RelevantPotentialsFinderType arg2=DSEP_BAYESBALL_POTENTIALS, gum::FindBarrenNodesType arg3=FIND_BARREN_NODES, bool use_binary_join_tree=True)"},
	 { "delete_LazyPropagation", _wrap_delete_LazyPropagation, METH_O, "delete_LazyPropagation(LazyPropagation self)"},
	 { "LazyPropagation_setTriangulation", _wrap_LazyPropagation_setTriangulation, METH_VARARGS, "LazyPropagation_setTriangulation(LazyPropagation self, Triangulation new_triangulation)"},
	 { "LazyPropagation_setRelevantPotentialsFinderType", _wrap_LazyPropagation_setRelevantPotentialsFinderType, METH_VARARGS, "\n"
		"LazyPropagation_setRelevantPotentialsFinderType(LazyPropagation self, gum::RelevantPotentialsFinderType type)\n"
		"\n"
		"sets how we determine the relevant potentials to combine\n"
		"\n"
		"When a clique sends a message to a separator, it first constitute the set of the potentials it contains and of the potentials contained in the messages it received. If RelevantPotentialsFinderType = FIND_ALL, all these potentials are combined and projected to produce the message sent to the separator. If RelevantPotentialsFinderType = DSEP_BAYESBALL_NODES, then only the set of potentials d-connected to the variables of the separator are kept for combination and projection.\n"
		"\n"
		"0 = FIND_ALL\n"
		"1 = DSEP_BAYESBALL_NODES\n"
		"2 = DSEP_BAYESBALL_POTENTIALS\n"
		"3 = DSEP_KOLLER_FRIEDMAN_2009\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type : int\n"
		"  the finder type\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If type is not implemented\n"
		"\n"
		""},
	 { "LazyPropagation_setFindBarrenNodesType", _wrap_LazyPropagation_setFindBarrenNodesType, METH_VARARGS, "\n"
		"LazyPropagation_setFindBarrenNodesType(LazyPropagation self, gum::FindBarrenNodesType type)\n"
		"\n"
		"sets how we determine barren nodes\n"
		"\n"
		"Barren nodes are unnecessary for probability inference, so they can be safely discarded in this case (type = FIND_BARREN_NODES). This speeds-up inference. However, there are some cases in which we do not want to remove barren nodes, typically when we want to answer queries such as Most Probable Explanations (MPE).\n"
		"\n"
		"0 = FIND_NO_BARREN_NODES\n"
		"1 = FIND_BARREN_NODES\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type : int\n"
		"  the finder type\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If type is not implemented\n"
		"\n"
		""},
	 { "LazyPropagation_joinTree", _wrap_LazyPropagation_joinTree, METH_O, "\n"
		"LazyPropagation_joinTree(LazyPropagation self) -> CliqueGraph\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.CliqueGraph\n"
		"  the current join tree used\n"
		"\n"
		""},
	 { "LazyPropagation_junctionTree", _wrap_LazyPropagation_junctionTree, METH_O, "\n"
		"LazyPropagation_junctionTree(LazyPropagation self) -> CliqueGraph\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.CliqueGraph\n"
		"  the current junction tree\n"
		"\n"
		""},
	 { "LazyPropagation_evidenceProbability", _wrap_LazyPropagation_evidenceProbability, METH_O, "\n"
		"LazyPropagation_evidenceProbability(LazyPropagation self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the probability of evidence\n"
		"\n"
		""},
	 { "LazyPropagation_setEvidence", _wrap_LazyPropagation_setEvidence, METH_VARARGS, "LazyPropagation_setEvidence(LazyPropagation self, PyObject * evidces)"},
	 { "LazyPropagation_updateEvidence", _wrap_LazyPropagation_updateEvidence, METH_VARARGS, "LazyPropagation_updateEvidence(LazyPropagation self, PyObject * evidces)"},
	 { "LazyPropagation_setTargets", _wrap_LazyPropagation_setTargets, METH_VARARGS, "LazyPropagation_setTargets(LazyPropagation self, PyObject * targets)"},
	 { "LazyPropagation_hardEvidenceNodes", _wrap_LazyPropagation_hardEvidenceNodes, METH_O, "\n"
		"LazyPropagation_hardEvidenceNodes(LazyPropagation self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "LazyPropagation_softEvidenceNodes", _wrap_LazyPropagation_softEvidenceNodes, METH_O, "\n"
		"LazyPropagation_softEvidenceNodes(LazyPropagation self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "LazyPropagation_targets", _wrap_LazyPropagation_targets, METH_O, "\n"
		"LazyPropagation_targets(LazyPropagation self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "LazyPropagation_jointMutualInformation", _wrap_LazyPropagation_jointMutualInformation, METH_VARARGS, "LazyPropagation_jointMutualInformation(LazyPropagation self, PyObject * targets) -> double"},
	 { "LazyPropagation_jointPosterior", _wrap_LazyPropagation_jointPosterior, METH_VARARGS, "\n"
		"LazyPropagation_jointPosterior(LazyPropagation self, PyObject * list) -> Potential\n"
		"\n"
		"Compute the joint posterior of a set of nodes.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"list :\n"
		"  the list of nodes whose posterior joint probability is wanted\n"
		"\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"The order of the variables given by the list here or when the jointTarget is declared can not be assumed to be used bu the Potential.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the posterior joint probability of the set of nodes.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LazyPropagation_addJointTarget", _wrap_LazyPropagation_addJointTarget, METH_VARARGS, "\n"
		"LazyPropagation_addJointTarget(LazyPropagation self, PyObject * list)\n"
		"\n"
		"Add a list of nodes as a new joint target. As a collateral effect, every node is added as a marginal target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"list\n"
		"  a list of names of nodes\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If some node(s) do not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_eraseJointTarget", _wrap_LazyPropagation_eraseJointTarget, METH_VARARGS, "\n"
		"LazyPropagation_eraseJointTarget(LazyPropagation self, PyObject * list)\n"
		"\n"
		"Remove, if existing, the joint target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"list\n"
		"  a list of names or Ids of nodes\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_isJointTarget", _wrap_LazyPropagation_isJointTarget, METH_VARARGS, "\n"
		"LazyPropagation_isJointTarget(LazyPropagation self, PyObject * list) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"list\n"
		"  a list of nodes ids or names.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if target is a joint target.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_jointTargets", _wrap_LazyPropagation_jointTargets, METH_O, "\n"
		"LazyPropagation_jointTargets(LazyPropagation self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of target sets\n"
		"\n"
		""},
	 { "LazyPropagation_makeInference", _wrap_LazyPropagation_makeInference, METH_O, "\n"
		"LazyPropagation_makeInference(LazyPropagation self)\n"
		"\n"
		"Perform the heavy computations needed to compute the targets' posteriors\n"
		"\n"
		"In a Junction tree propagation scheme, for instance, the heavy computations are those of the messages sent in the JT.\n"
		"This is precisely what makeInference should compute. Later, the computations of the posteriors can be done 'lightly' by multiplying and projecting those messages.\n"
		"\n"
		""},
	 { "LazyPropagation_posterior", _wrap_LazyPropagation_posterior, METH_VARARGS, "\n"
		"LazyPropagation_posterior(LazyPropagation self, gum::NodeId const var) -> Potential\n"
		"LazyPropagation_posterior(LazyPropagation self, std::string const nodeName) -> Potential\n"
		"\n"
		"Computes and returns the posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LazyPropagation_BN", _wrap_LazyPropagation_BN, METH_O, "\n"
		"LazyPropagation_BN(LazyPropagation self) -> IBayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "LazyPropagation_addEvidence", _wrap_LazyPropagation_addEvidence, METH_VARARGS, "\n"
		"LazyPropagation_addEvidence(LazyPropagation self, gum::NodeId const id, gum::Idx const val)\n"
		"LazyPropagation_addEvidence(LazyPropagation self, std::string const & nodeName, gum::Idx const val)\n"
		"LazyPropagation_addEvidence(LazyPropagation self, gum::NodeId const id, std::string const & val)\n"
		"LazyPropagation_addEvidence(LazyPropagation self, std::string const & nodeName, std::string const & val)\n"
		"LazyPropagation_addEvidence(LazyPropagation self, gum::NodeId const id, Vector vals)\n"
		"LazyPropagation_addEvidence(LazyPropagation self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Adds a new evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node already has an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_chgEvidence", _wrap_LazyPropagation_chgEvidence, METH_VARARGS, "\n"
		"LazyPropagation_chgEvidence(LazyPropagation self, gum::NodeId const id, gum::Idx const val)\n"
		"LazyPropagation_chgEvidence(LazyPropagation self, std::string const & nodeName, gum::Idx const val)\n"
		"LazyPropagation_chgEvidence(LazyPropagation self, gum::NodeId const id, std::string const & val)\n"
		"LazyPropagation_chgEvidence(LazyPropagation self, std::string const & nodeName, std::string const & val)\n"
		"LazyPropagation_chgEvidence(LazyPropagation self, gum::NodeId const id, Vector vals)\n"
		"LazyPropagation_chgEvidence(LazyPropagation self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Change the value of an already existing evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_hasEvidence", _wrap_LazyPropagation_hasEvidence, METH_VARARGS, "\n"
		"LazyPropagation_hasEvidence(LazyPropagation self, gum::NodeId const id) -> bool\n"
		"LazyPropagation_hasEvidence(LazyPropagation self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if some node(s) (or the one in parameters) have received evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_eraseAllEvidence", _wrap_LazyPropagation_eraseAllEvidence, METH_O, "\n"
		"LazyPropagation_eraseAllEvidence(LazyPropagation self)\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "LazyPropagation_eraseEvidence", _wrap_LazyPropagation_eraseEvidence, METH_VARARGS, "\n"
		"LazyPropagation_eraseEvidence(LazyPropagation self, gum::NodeId const id)\n"
		"LazyPropagation_eraseEvidence(LazyPropagation self, std::string const & nodeName)\n"
		"\n"
		"Remove the evidence, if any, corresponding to the node Id or name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_hasHardEvidence", _wrap_LazyPropagation_hasHardEvidence, METH_VARARGS, "\n"
		"LazyPropagation_hasHardEvidence(LazyPropagation self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a hard evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_hasSoftEvidence", _wrap_LazyPropagation_hasSoftEvidence, METH_VARARGS, "\n"
		"LazyPropagation_hasSoftEvidence(LazyPropagation self, gum::NodeId const id) -> bool\n"
		"LazyPropagation_hasSoftEvidence(LazyPropagation self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a soft evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_nbrEvidence", _wrap_LazyPropagation_nbrEvidence, METH_O, "\n"
		"LazyPropagation_nbrEvidence(LazyPropagation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_nbrHardEvidence", _wrap_LazyPropagation_nbrHardEvidence, METH_O, "\n"
		"LazyPropagation_nbrHardEvidence(LazyPropagation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of hard evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_nbrSoftEvidence", _wrap_LazyPropagation_nbrSoftEvidence, METH_O, "\n"
		"LazyPropagation_nbrSoftEvidence(LazyPropagation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of soft evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_eraseAllTargets", _wrap_LazyPropagation_eraseAllTargets, METH_O, "\n"
		"LazyPropagation_eraseAllTargets(LazyPropagation self)\n"
		"\n"
		"Clear all previously defined targets (marginal and joint targets).\n"
		"\n"
		"As a result, no posterior can be computed (since we can only compute the posteriors of the marginal or joint targets that have been added by the user).\n"
		"\n"
		""},
	 { "LazyPropagation_addAllTargets", _wrap_LazyPropagation_addAllTargets, METH_O, "\n"
		"LazyPropagation_addAllTargets(LazyPropagation self)\n"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "LazyPropagation_addTarget", _wrap_LazyPropagation_addTarget, METH_VARARGS, "\n"
		"LazyPropagation_addTarget(LazyPropagation self, gum::NodeId const target)\n"
		"LazyPropagation_addTarget(LazyPropagation self, std::string const & nodeName)\n"
		"\n"
		"Add a marginal target to the list of targets.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "LazyPropagation_eraseTarget", _wrap_LazyPropagation_eraseTarget, METH_VARARGS, "\n"
		"LazyPropagation_eraseTarget(LazyPropagation self, gum::NodeId const target)\n"
		"LazyPropagation_eraseTarget(LazyPropagation self, std::string const & nodeName)\n"
		"\n"
		"Remove, if existing, the marginal target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_isTarget", _wrap_LazyPropagation_isTarget, METH_VARARGS, "\n"
		"LazyPropagation_isTarget(LazyPropagation self, gum::NodeId const variable) -> bool\n"
		"LazyPropagation_isTarget(LazyPropagation self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : int\n"
		" a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variable is a (marginal) target\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LazyPropagation_nbrTargets", _wrap_LazyPropagation_nbrTargets, METH_O, "\n"
		"LazyPropagation_nbrTargets(LazyPropagation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "LazyPropagation_H", _wrap_LazyPropagation_H, METH_VARARGS, "\n"
		"LazyPropagation_H(LazyPropagation self, gum::NodeId const X) -> double\n"
		"LazyPropagation_H(LazyPropagation self, std::string const & nodeName) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "LazyPropagation_evidenceImpact", _wrap_LazyPropagation_evidenceImpact, METH_VARARGS, "\n"
		"LazyPropagation_evidenceImpact(LazyPropagation self, gum::NodeId target, PyObject * evs) -> Potential\n"
		"LazyPropagation_evidenceImpact(LazyPropagation self, std::string const & target, Vector_string evs) -> Potential\n"
		"\n"
		"Create a pyAgrum.Potential for P(target|evs) (for all instanciation of target and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : set\n"
		"  a set of targets ids or names.\n"
		"evs : set\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"if some evs are d-separated, they are not included in the Potential.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a Potential for P(targets|evs)\n"
		"\n"
		""},
	 { "LazyPropagation_eraseAllJointTargets", _wrap_LazyPropagation_eraseAllJointTargets, METH_O, "\n"
		"LazyPropagation_eraseAllJointTargets(LazyPropagation self)\n"
		"\n"
		"Clear all previously defined joint targets.\n"
		"\n"
		""},
	 { "LazyPropagation_eraseAllMarginalTargets", _wrap_LazyPropagation_eraseAllMarginalTargets, METH_O, "\n"
		"LazyPropagation_eraseAllMarginalTargets(LazyPropagation self)\n"
		"\n"
		"Clear all the previously defined marginal targets.\n"
		"\n"
		""},
	 { "LazyPropagation_nbrJointTargets", _wrap_LazyPropagation_nbrJointTargets, METH_O, "\n"
		"LazyPropagation_nbrJointTargets(LazyPropagation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of joint targets\n"
		"\n"
		""},
	 { "LazyPropagation_I", _wrap_LazyPropagation_I, METH_VARARGS, "\n"
		"LazyPropagation_I(LazyPropagation self, gum::NodeId const X, gum::NodeId const Y) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"Y : int\n"
		"  another node Id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "LazyPropagation_VI", _wrap_LazyPropagation_VI, METH_VARARGS, "\n"
		"LazyPropagation_VI(LazyPropagation self, gum::NodeId const X, gum::NodeId const Y) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"Y : int\n"
		"  another node Id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  variation of information between X and Y\n"
		"\n"
		""},
	 { "LazyPropagation_evidenceJointImpact", _wrap_LazyPropagation_evidenceJointImpact, METH_VARARGS, "\n"
		"LazyPropagation_evidenceJointImpact(LazyPropagation self, PyObject * targets, PyObject * evs) -> Potential\n"
		"LazyPropagation_evidenceJointImpact(LazyPropagation self, Vector_string targets, Vector_string evs) -> Potential\n"
		"\n"
		"Create a pyAgrum.Potential for P(joint targets|evs) (for all instanciation of targets and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"targets :\n"
		"  (int) a node Id\n"
		"targets :\n"
		"  (str) a node name\n"
		"evs : set\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a Potential for P(target|evs)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.Exception\n"
		"  If some evidene entered into the Bayes net are incompatible (their joint proba = 0)\n"
		"\n"
		""},
	 { "LazyPropagation_swigregister", LazyPropagation_swigregister, METH_VARARGS, NULL},
	 { "LazyPropagation_swiginit", LazyPropagation_swiginit, METH_VARARGS, NULL},
	 { "new_ShaferShenoyInference", _wrap_new_ShaferShenoyInference, METH_VARARGS, "ShaferShenoyInference(IBayesNet BN, gum::FindBarrenNodesType barren_type=FIND_BARREN_NODES, bool use_binary_join_tree=True)"},
	 { "delete_ShaferShenoyInference", _wrap_delete_ShaferShenoyInference, METH_O, "delete_ShaferShenoyInference(ShaferShenoyInference self)"},
	 { "ShaferShenoyInference_setTriangulation", _wrap_ShaferShenoyInference_setTriangulation, METH_VARARGS, "ShaferShenoyInference_setTriangulation(ShaferShenoyInference self, Triangulation new_triangulation)"},
	 { "ShaferShenoyInference_setFindBarrenNodesType", _wrap_ShaferShenoyInference_setFindBarrenNodesType, METH_VARARGS, "\n"
		"ShaferShenoyInference_setFindBarrenNodesType(ShaferShenoyInference self, gum::FindBarrenNodesType type)\n"
		"\n"
		"sets how we determine barren nodes\n"
		"\n"
		"Barren nodes are unnecessary for probability inference, so they can be safely discarded in this case (type = FIND_BARREN_NODES). This speeds-up inference. However, there are some cases in which we do not want to remove barren nodes, typically when we want to answer queries such as Most Probable Explanations (MPE).\n"
		"\n"
		"0 = FIND_NO_BARREN_NODES\n"
		"1 = FIND_BARREN_NODES\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type : int\n"
		"  the finder type\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If type is not implemented\n"
		"\n"
		""},
	 { "ShaferShenoyInference_joinTree", _wrap_ShaferShenoyInference_joinTree, METH_O, "\n"
		"ShaferShenoyInference_joinTree(ShaferShenoyInference self) -> CliqueGraph\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.CliqueGraph\n"
		"  the current join tree used\n"
		"\n"
		""},
	 { "ShaferShenoyInference_junctionTree", _wrap_ShaferShenoyInference_junctionTree, METH_O, "\n"
		"ShaferShenoyInference_junctionTree(ShaferShenoyInference self) -> CliqueGraph\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.CliqueGraph\n"
		"  the current junction tree\n"
		"\n"
		""},
	 { "ShaferShenoyInference_evidenceProbability", _wrap_ShaferShenoyInference_evidenceProbability, METH_O, "\n"
		"ShaferShenoyInference_evidenceProbability(ShaferShenoyInference self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the probability of evidence\n"
		"\n"
		""},
	 { "ShaferShenoyInference_setEvidence", _wrap_ShaferShenoyInference_setEvidence, METH_VARARGS, "ShaferShenoyInference_setEvidence(ShaferShenoyInference self, PyObject * evidces)"},
	 { "ShaferShenoyInference_updateEvidence", _wrap_ShaferShenoyInference_updateEvidence, METH_VARARGS, "ShaferShenoyInference_updateEvidence(ShaferShenoyInference self, PyObject * evidces)"},
	 { "ShaferShenoyInference_setTargets", _wrap_ShaferShenoyInference_setTargets, METH_VARARGS, "ShaferShenoyInference_setTargets(ShaferShenoyInference self, PyObject * targets)"},
	 { "ShaferShenoyInference_hardEvidenceNodes", _wrap_ShaferShenoyInference_hardEvidenceNodes, METH_O, "\n"
		"ShaferShenoyInference_hardEvidenceNodes(ShaferShenoyInference self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "ShaferShenoyInference_softEvidenceNodes", _wrap_ShaferShenoyInference_softEvidenceNodes, METH_O, "\n"
		"ShaferShenoyInference_softEvidenceNodes(ShaferShenoyInference self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "ShaferShenoyInference_targets", _wrap_ShaferShenoyInference_targets, METH_O, "\n"
		"ShaferShenoyInference_targets(ShaferShenoyInference self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "ShaferShenoyInference_jointMutualInformation", _wrap_ShaferShenoyInference_jointMutualInformation, METH_VARARGS, "ShaferShenoyInference_jointMutualInformation(ShaferShenoyInference self, PyObject * targets) -> double"},
	 { "ShaferShenoyInference_jointPosterior", _wrap_ShaferShenoyInference_jointPosterior, METH_VARARGS, "\n"
		"ShaferShenoyInference_jointPosterior(ShaferShenoyInference self, PyObject * list) -> Potential\n"
		"\n"
		"Compute the joint posterior of a set of nodes.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"list :\n"
		"  the list of nodes whose posterior joint probability is wanted\n"
		"\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"The order of the variables given by the list here or when the jointTarget is declared can not be assumed to be used bu the Potential.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the posterior joint probability of the set of nodes.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "ShaferShenoyInference_addJointTarget", _wrap_ShaferShenoyInference_addJointTarget, METH_VARARGS, "\n"
		"ShaferShenoyInference_addJointTarget(ShaferShenoyInference self, PyObject * list)\n"
		"\n"
		"Add a list of nodes as a new joint target. As a collateral effect, every node is added as a marginal target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"list\n"
		"  a list of names of nodes\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If some node(s) do not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_eraseJointTarget", _wrap_ShaferShenoyInference_eraseJointTarget, METH_VARARGS, "\n"
		"ShaferShenoyInference_eraseJointTarget(ShaferShenoyInference self, PyObject * list)\n"
		"\n"
		"Remove, if existing, the joint target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"list\n"
		"  a list of names or Ids of nodes\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_isJointTarget", _wrap_ShaferShenoyInference_isJointTarget, METH_VARARGS, "\n"
		"ShaferShenoyInference_isJointTarget(ShaferShenoyInference self, PyObject * list) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"list\n"
		"  a list of nodes ids or names.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if target is a joint target.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_jointTargets", _wrap_ShaferShenoyInference_jointTargets, METH_O, "\n"
		"ShaferShenoyInference_jointTargets(ShaferShenoyInference self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of target sets\n"
		"\n"
		""},
	 { "ShaferShenoyInference_makeInference", _wrap_ShaferShenoyInference_makeInference, METH_O, "\n"
		"ShaferShenoyInference_makeInference(ShaferShenoyInference self)\n"
		"\n"
		"Perform the heavy computations needed to compute the targets' posteriors\n"
		"\n"
		"In a Junction tree propagation scheme, for instance, the heavy computations are those of the messages sent in the JT.\n"
		"This is precisely what makeInference should compute. Later, the computations of the posteriors can be done 'lightly' by multiplying and projecting those messages.\n"
		"\n"
		""},
	 { "ShaferShenoyInference_posterior", _wrap_ShaferShenoyInference_posterior, METH_VARARGS, "\n"
		"ShaferShenoyInference_posterior(ShaferShenoyInference self, gum::NodeId const var) -> Potential\n"
		"ShaferShenoyInference_posterior(ShaferShenoyInference self, std::string const nodeName) -> Potential\n"
		"\n"
		"Computes and returns the posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "ShaferShenoyInference_BN", _wrap_ShaferShenoyInference_BN, METH_O, "\n"
		"ShaferShenoyInference_BN(ShaferShenoyInference self) -> IBayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "ShaferShenoyInference_addEvidence", _wrap_ShaferShenoyInference_addEvidence, METH_VARARGS, "\n"
		"ShaferShenoyInference_addEvidence(ShaferShenoyInference self, gum::NodeId const id, gum::Idx const val)\n"
		"ShaferShenoyInference_addEvidence(ShaferShenoyInference self, std::string const & nodeName, gum::Idx const val)\n"
		"ShaferShenoyInference_addEvidence(ShaferShenoyInference self, gum::NodeId const id, std::string const & val)\n"
		"ShaferShenoyInference_addEvidence(ShaferShenoyInference self, std::string const & nodeName, std::string const & val)\n"
		"ShaferShenoyInference_addEvidence(ShaferShenoyInference self, gum::NodeId const id, Vector vals)\n"
		"ShaferShenoyInference_addEvidence(ShaferShenoyInference self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Adds a new evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node already has an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_chgEvidence", _wrap_ShaferShenoyInference_chgEvidence, METH_VARARGS, "\n"
		"ShaferShenoyInference_chgEvidence(ShaferShenoyInference self, gum::NodeId const id, gum::Idx const val)\n"
		"ShaferShenoyInference_chgEvidence(ShaferShenoyInference self, std::string const & nodeName, gum::Idx const val)\n"
		"ShaferShenoyInference_chgEvidence(ShaferShenoyInference self, gum::NodeId const id, std::string const & val)\n"
		"ShaferShenoyInference_chgEvidence(ShaferShenoyInference self, std::string const & nodeName, std::string const & val)\n"
		"ShaferShenoyInference_chgEvidence(ShaferShenoyInference self, gum::NodeId const id, Vector vals)\n"
		"ShaferShenoyInference_chgEvidence(ShaferShenoyInference self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Change the value of an already existing evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_hasEvidence", _wrap_ShaferShenoyInference_hasEvidence, METH_VARARGS, "\n"
		"ShaferShenoyInference_hasEvidence(ShaferShenoyInference self, gum::NodeId const id) -> bool\n"
		"ShaferShenoyInference_hasEvidence(ShaferShenoyInference self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if some node(s) (or the one in parameters) have received evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_eraseAllEvidence", _wrap_ShaferShenoyInference_eraseAllEvidence, METH_O, "\n"
		"ShaferShenoyInference_eraseAllEvidence(ShaferShenoyInference self)\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "ShaferShenoyInference_eraseEvidence", _wrap_ShaferShenoyInference_eraseEvidence, METH_VARARGS, "\n"
		"ShaferShenoyInference_eraseEvidence(ShaferShenoyInference self, gum::NodeId const id)\n"
		"ShaferShenoyInference_eraseEvidence(ShaferShenoyInference self, std::string const & nodeName)\n"
		"\n"
		"Remove the evidence, if any, corresponding to the node Id or name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_hasHardEvidence", _wrap_ShaferShenoyInference_hasHardEvidence, METH_VARARGS, "\n"
		"ShaferShenoyInference_hasHardEvidence(ShaferShenoyInference self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a hard evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_hasSoftEvidence", _wrap_ShaferShenoyInference_hasSoftEvidence, METH_VARARGS, "\n"
		"ShaferShenoyInference_hasSoftEvidence(ShaferShenoyInference self, gum::NodeId const id) -> bool\n"
		"ShaferShenoyInference_hasSoftEvidence(ShaferShenoyInference self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a soft evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_nbrEvidence", _wrap_ShaferShenoyInference_nbrEvidence, METH_O, "\n"
		"ShaferShenoyInference_nbrEvidence(ShaferShenoyInference self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_nbrHardEvidence", _wrap_ShaferShenoyInference_nbrHardEvidence, METH_O, "\n"
		"ShaferShenoyInference_nbrHardEvidence(ShaferShenoyInference self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of hard evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_nbrSoftEvidence", _wrap_ShaferShenoyInference_nbrSoftEvidence, METH_O, "\n"
		"ShaferShenoyInference_nbrSoftEvidence(ShaferShenoyInference self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of soft evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_eraseAllTargets", _wrap_ShaferShenoyInference_eraseAllTargets, METH_O, "\n"
		"ShaferShenoyInference_eraseAllTargets(ShaferShenoyInference self)\n"
		"\n"
		"Clear all previously defined targets (marginal and joint targets).\n"
		"\n"
		"As a result, no posterior can be computed (since we can only compute the posteriors of the marginal or joint targets that have been added by the user).\n"
		"\n"
		""},
	 { "ShaferShenoyInference_addAllTargets", _wrap_ShaferShenoyInference_addAllTargets, METH_O, "\n"
		"ShaferShenoyInference_addAllTargets(ShaferShenoyInference self)\n"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "ShaferShenoyInference_addTarget", _wrap_ShaferShenoyInference_addTarget, METH_VARARGS, "\n"
		"ShaferShenoyInference_addTarget(ShaferShenoyInference self, gum::NodeId const target)\n"
		"ShaferShenoyInference_addTarget(ShaferShenoyInference self, std::string const & nodeName)\n"
		"\n"
		"Add a marginal target to the list of targets.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "ShaferShenoyInference_eraseTarget", _wrap_ShaferShenoyInference_eraseTarget, METH_VARARGS, "\n"
		"ShaferShenoyInference_eraseTarget(ShaferShenoyInference self, gum::NodeId const target)\n"
		"ShaferShenoyInference_eraseTarget(ShaferShenoyInference self, std::string const & nodeName)\n"
		"\n"
		"Remove, if existing, the marginal target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_isTarget", _wrap_ShaferShenoyInference_isTarget, METH_VARARGS, "\n"
		"ShaferShenoyInference_isTarget(ShaferShenoyInference self, gum::NodeId const variable) -> bool\n"
		"ShaferShenoyInference_isTarget(ShaferShenoyInference self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : int\n"
		" a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variable is a (marginal) target\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ShaferShenoyInference_nbrTargets", _wrap_ShaferShenoyInference_nbrTargets, METH_O, "\n"
		"ShaferShenoyInference_nbrTargets(ShaferShenoyInference self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "ShaferShenoyInference_H", _wrap_ShaferShenoyInference_H, METH_VARARGS, "\n"
		"ShaferShenoyInference_H(ShaferShenoyInference self, gum::NodeId const X) -> double\n"
		"ShaferShenoyInference_H(ShaferShenoyInference self, std::string const & nodeName) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "ShaferShenoyInference_evidenceImpact", _wrap_ShaferShenoyInference_evidenceImpact, METH_VARARGS, "\n"
		"ShaferShenoyInference_evidenceImpact(ShaferShenoyInference self, gum::NodeId target, PyObject * evs) -> Potential\n"
		"ShaferShenoyInference_evidenceImpact(ShaferShenoyInference self, std::string const & target, Vector_string evs) -> Potential\n"
		"\n"
		"Create a pyAgrum.Potential for P(target|evs) (for all instanciation of target and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : set\n"
		"  a set of targets ids or names.\n"
		"evs : set\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"if some evs are d-separated, they are not included in the Potential.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a Potential for P(targets|evs)\n"
		"\n"
		""},
	 { "ShaferShenoyInference_eraseAllJointTargets", _wrap_ShaferShenoyInference_eraseAllJointTargets, METH_O, "\n"
		"ShaferShenoyInference_eraseAllJointTargets(ShaferShenoyInference self)\n"
		"\n"
		"Clear all previously defined joint targets.\n"
		"\n"
		""},
	 { "ShaferShenoyInference_eraseAllMarginalTargets", _wrap_ShaferShenoyInference_eraseAllMarginalTargets, METH_O, "\n"
		"ShaferShenoyInference_eraseAllMarginalTargets(ShaferShenoyInference self)\n"
		"\n"
		"Clear all the previously defined marginal targets.\n"
		"\n"
		""},
	 { "ShaferShenoyInference_nbrJointTargets", _wrap_ShaferShenoyInference_nbrJointTargets, METH_O, "\n"
		"ShaferShenoyInference_nbrJointTargets(ShaferShenoyInference self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of joint targets\n"
		"\n"
		""},
	 { "ShaferShenoyInference_I", _wrap_ShaferShenoyInference_I, METH_VARARGS, "\n"
		"ShaferShenoyInference_I(ShaferShenoyInference self, gum::NodeId const X, gum::NodeId const Y) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"Y : int\n"
		"  another node Id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "ShaferShenoyInference_VI", _wrap_ShaferShenoyInference_VI, METH_VARARGS, "\n"
		"ShaferShenoyInference_VI(ShaferShenoyInference self, gum::NodeId const X, gum::NodeId const Y) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"Y : int\n"
		"  another node Id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  variation of information between X and Y\n"
		"\n"
		""},
	 { "ShaferShenoyInference_evidenceJointImpact", _wrap_ShaferShenoyInference_evidenceJointImpact, METH_VARARGS, "\n"
		"ShaferShenoyInference_evidenceJointImpact(ShaferShenoyInference self, PyObject * targets, PyObject * evs) -> Potential\n"
		"ShaferShenoyInference_evidenceJointImpact(ShaferShenoyInference self, Vector_string targets, Vector_string evs) -> Potential\n"
		"\n"
		"Create a pyAgrum.Potential for P(joint targets|evs) (for all instanciation of targets and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"targets :\n"
		"  (int) a node Id\n"
		"targets :\n"
		"  (str) a node name\n"
		"evs : set\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a Potential for P(target|evs)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.Exception\n"
		"  If some evidene entered into the Bayes net are incompatible (their joint proba = 0)\n"
		"\n"
		""},
	 { "ShaferShenoyInference_swigregister", ShaferShenoyInference_swigregister, METH_VARARGS, NULL},
	 { "ShaferShenoyInference_swiginit", ShaferShenoyInference_swiginit, METH_VARARGS, NULL},
	 { "new_VariableElimination", _wrap_new_VariableElimination, METH_VARARGS, "VariableElimination(IBayesNet BN, gum::RelevantPotentialsFinderType relevant_type=DSEP_BAYESBALL_POTENTIALS, gum::FindBarrenNodesType arg3=FIND_BARREN_NODES)"},
	 { "delete_VariableElimination", _wrap_delete_VariableElimination, METH_O, "delete_VariableElimination(VariableElimination self)"},
	 { "VariableElimination_setTriangulation", _wrap_VariableElimination_setTriangulation, METH_VARARGS, "VariableElimination_setTriangulation(VariableElimination self, Triangulation new_triangulation)"},
	 { "VariableElimination_setRelevantPotentialsFinderType", _wrap_VariableElimination_setRelevantPotentialsFinderType, METH_VARARGS, "\n"
		"VariableElimination_setRelevantPotentialsFinderType(VariableElimination self, gum::RelevantPotentialsFinderType type)\n"
		"\n"
		"sets how we determine the relevant potentials to combine\n"
		"\n"
		"When a clique sends a message to a separator, it first constitute the set of the potentials it contains and of the potentials contained in the messages it received. If RelevantPotentialsFinderType = FIND_ALL, all these potentials are combined and projected to produce the message sent to the separator. If RelevantPotentialsFinderType = DSEP_BAYESBALL_NODES, then only the set of potentials d-connected to the variables of the separator are kept for combination and projection.\n"
		"\n"
		"0 = FIND_ALL\n"
		"1 = DSEP_BAYESBALL_NODES\n"
		"2 = DSEP_BAYESBALL_POTENTIALS\n"
		"3 = DSEP_KOLLER_FRIEDMAN_2009\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type : int\n"
		"  the finder type\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If type is not implemented\n"
		"\n"
		""},
	 { "VariableElimination_setFindBarrenNodesType", _wrap_VariableElimination_setFindBarrenNodesType, METH_VARARGS, "\n"
		"VariableElimination_setFindBarrenNodesType(VariableElimination self, gum::FindBarrenNodesType type)\n"
		"\n"
		"sets how we determine barren nodes\n"
		"\n"
		"Barren nodes are unnecessary for probability inference, so they can be safely discarded in this case (type = FIND_BARREN_NODES). This speeds-up inference. However, there are some cases in which we do not want to remove barren nodes, typically when we want to answer queries such as Most Probable Explanations (MPE).\n"
		"\n"
		"0 = FIND_NO_BARREN_NODES\n"
		"1 = FIND_BARREN_NODES\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type : int\n"
		"  the finder type\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If type is not implemented\n"
		"\n"
		""},
	 { "VariableElimination_junctionTree", _wrap_VariableElimination_junctionTree, METH_VARARGS, "\n"
		"VariableElimination_junctionTree(VariableElimination self, gum::NodeId id) -> CliqueGraph\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.CliqueGraph\n"
		"  the current junction tree\n"
		"\n"
		""},
	 { "VariableElimination_setEvidence", _wrap_VariableElimination_setEvidence, METH_VARARGS, "VariableElimination_setEvidence(VariableElimination self, PyObject * evidces)"},
	 { "VariableElimination_updateEvidence", _wrap_VariableElimination_updateEvidence, METH_VARARGS, "VariableElimination_updateEvidence(VariableElimination self, PyObject * evidces)"},
	 { "VariableElimination_setTargets", _wrap_VariableElimination_setTargets, METH_VARARGS, "VariableElimination_setTargets(VariableElimination self, PyObject * targets)"},
	 { "VariableElimination_hardEvidenceNodes", _wrap_VariableElimination_hardEvidenceNodes, METH_O, "\n"
		"VariableElimination_hardEvidenceNodes(VariableElimination self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "VariableElimination_softEvidenceNodes", _wrap_VariableElimination_softEvidenceNodes, METH_O, "\n"
		"VariableElimination_softEvidenceNodes(VariableElimination self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "VariableElimination_targets", _wrap_VariableElimination_targets, METH_O, "\n"
		"VariableElimination_targets(VariableElimination self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "VariableElimination_jointMutualInformation", _wrap_VariableElimination_jointMutualInformation, METH_VARARGS, "VariableElimination_jointMutualInformation(VariableElimination self, PyObject * targets) -> double"},
	 { "VariableElimination_evidenceJointImpact", _wrap_VariableElimination_evidenceJointImpact, METH_VARARGS, "\n"
		"VariableElimination_evidenceJointImpact(VariableElimination self, PyObject * targets, PyObject * evs) -> Potential\n"
		"\n"
		"Create a pyAgrum.Potential for P(joint targets|evs) (for all instanciation of targets and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"targets :\n"
		"  (int) a node Id\n"
		"targets :\n"
		"  (str) a node name\n"
		"evs : set\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a Potential for P(target|evs)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.Exception\n"
		"  If some evidene entered into the Bayes net are incompatible (their joint proba = 0)\n"
		"\n"
		""},
	 { "VariableElimination_jointPosterior", _wrap_VariableElimination_jointPosterior, METH_VARARGS, "\n"
		"VariableElimination_jointPosterior(VariableElimination self, PyObject * list) -> Potential\n"
		"\n"
		"Compute the joint posterior of a set of nodes.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"list :\n"
		"  the list of nodes whose posterior joint probability is wanted\n"
		"\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"The order of the variables given by the list here or when the jointTarget is declared can not be assumed to be used bu the Potential.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the posterior joint probability of the set of nodes.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "VariableElimination_addJointTarget", _wrap_VariableElimination_addJointTarget, METH_VARARGS, "\n"
		"VariableElimination_addJointTarget(VariableElimination self, PyObject * list)\n"
		"\n"
		"Add a list of nodes as a new joint target. As a collateral effect, every node is added as a marginal target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"list\n"
		"  a list of names of nodes\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If some node(s) do not belong to the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_eraseJointTarget", _wrap_VariableElimination_eraseJointTarget, METH_VARARGS, "\n"
		"VariableElimination_eraseJointTarget(VariableElimination self, PyObject * list)\n"
		"\n"
		"Remove, if existing, the joint target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"list\n"
		"  a list of names or Ids of nodes\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_isJointTarget", _wrap_VariableElimination_isJointTarget, METH_VARARGS, "\n"
		"VariableElimination_isJointTarget(VariableElimination self, PyObject * list) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"list\n"
		"  a list of nodes ids or names.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if target is a joint target.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_jointTargets", _wrap_VariableElimination_jointTargets, METH_O, "\n"
		"VariableElimination_jointTargets(VariableElimination self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of target sets\n"
		"\n"
		""},
	 { "VariableElimination_makeInference", _wrap_VariableElimination_makeInference, METH_O, "\n"
		"VariableElimination_makeInference(VariableElimination self)\n"
		"\n"
		"Perform the heavy computations needed to compute the targets' posteriors\n"
		"\n"
		"In a Junction tree propagation scheme, for instance, the heavy computations are those of the messages sent in the JT.\n"
		"This is precisely what makeInference should compute. Later, the computations of the posteriors can be done 'lightly' by multiplying and projecting those messages.\n"
		"\n"
		""},
	 { "VariableElimination_posterior", _wrap_VariableElimination_posterior, METH_VARARGS, "\n"
		"VariableElimination_posterior(VariableElimination self, gum::NodeId const var) -> Potential\n"
		"VariableElimination_posterior(VariableElimination self, std::string const nodeName) -> Potential\n"
		"\n"
		"Computes and returns the posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "VariableElimination_BN", _wrap_VariableElimination_BN, METH_O, "\n"
		"VariableElimination_BN(VariableElimination self) -> IBayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "VariableElimination_addEvidence", _wrap_VariableElimination_addEvidence, METH_VARARGS, "\n"
		"VariableElimination_addEvidence(VariableElimination self, gum::NodeId const id, gum::Idx const val)\n"
		"VariableElimination_addEvidence(VariableElimination self, std::string const & nodeName, gum::Idx const val)\n"
		"VariableElimination_addEvidence(VariableElimination self, gum::NodeId const id, std::string const & val)\n"
		"VariableElimination_addEvidence(VariableElimination self, std::string const & nodeName, std::string const & val)\n"
		"VariableElimination_addEvidence(VariableElimination self, gum::NodeId const id, Vector vals)\n"
		"VariableElimination_addEvidence(VariableElimination self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Adds a new evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node already has an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_chgEvidence", _wrap_VariableElimination_chgEvidence, METH_VARARGS, "\n"
		"VariableElimination_chgEvidence(VariableElimination self, gum::NodeId const id, gum::Idx const val)\n"
		"VariableElimination_chgEvidence(VariableElimination self, std::string const & nodeName, gum::Idx const val)\n"
		"VariableElimination_chgEvidence(VariableElimination self, gum::NodeId const id, std::string const & val)\n"
		"VariableElimination_chgEvidence(VariableElimination self, std::string const & nodeName, std::string const & val)\n"
		"VariableElimination_chgEvidence(VariableElimination self, gum::NodeId const id, Vector vals)\n"
		"VariableElimination_chgEvidence(VariableElimination self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Change the value of an already existing evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_hasEvidence", _wrap_VariableElimination_hasEvidence, METH_VARARGS, "\n"
		"VariableElimination_hasEvidence(VariableElimination self, gum::NodeId const id) -> bool\n"
		"VariableElimination_hasEvidence(VariableElimination self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if some node(s) (or the one in parameters) have received evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_eraseAllEvidence", _wrap_VariableElimination_eraseAllEvidence, METH_O, "\n"
		"VariableElimination_eraseAllEvidence(VariableElimination self)\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "VariableElimination_eraseEvidence", _wrap_VariableElimination_eraseEvidence, METH_VARARGS, "\n"
		"VariableElimination_eraseEvidence(VariableElimination self, gum::NodeId const id)\n"
		"VariableElimination_eraseEvidence(VariableElimination self, std::string const & nodeName)\n"
		"\n"
		"Remove the evidence, if any, corresponding to the node Id or name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_hasHardEvidence", _wrap_VariableElimination_hasHardEvidence, METH_VARARGS, "\n"
		"VariableElimination_hasHardEvidence(VariableElimination self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a hard evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_hasSoftEvidence", _wrap_VariableElimination_hasSoftEvidence, METH_VARARGS, "\n"
		"VariableElimination_hasSoftEvidence(VariableElimination self, gum::NodeId const id) -> bool\n"
		"VariableElimination_hasSoftEvidence(VariableElimination self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a soft evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_nbrEvidence", _wrap_VariableElimination_nbrEvidence, METH_O, "\n"
		"VariableElimination_nbrEvidence(VariableElimination self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_nbrHardEvidence", _wrap_VariableElimination_nbrHardEvidence, METH_O, "\n"
		"VariableElimination_nbrHardEvidence(VariableElimination self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of hard evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_nbrSoftEvidence", _wrap_VariableElimination_nbrSoftEvidence, METH_O, "\n"
		"VariableElimination_nbrSoftEvidence(VariableElimination self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of soft evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_eraseAllTargets", _wrap_VariableElimination_eraseAllTargets, METH_O, "\n"
		"VariableElimination_eraseAllTargets(VariableElimination self)\n"
		"\n"
		"Clear all previously defined targets (marginal and joint targets).\n"
		"\n"
		"As a result, no posterior can be computed (since we can only compute the posteriors of the marginal or joint targets that have been added by the user).\n"
		"\n"
		""},
	 { "VariableElimination_addAllTargets", _wrap_VariableElimination_addAllTargets, METH_O, "\n"
		"VariableElimination_addAllTargets(VariableElimination self)\n"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "VariableElimination_addTarget", _wrap_VariableElimination_addTarget, METH_VARARGS, "\n"
		"VariableElimination_addTarget(VariableElimination self, gum::NodeId const target)\n"
		"VariableElimination_addTarget(VariableElimination self, std::string const & nodeName)\n"
		"\n"
		"Add a marginal target to the list of targets.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "VariableElimination_eraseTarget", _wrap_VariableElimination_eraseTarget, METH_VARARGS, "\n"
		"VariableElimination_eraseTarget(VariableElimination self, gum::NodeId const target)\n"
		"VariableElimination_eraseTarget(VariableElimination self, std::string const & nodeName)\n"
		"\n"
		"Remove, if existing, the marginal target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_isTarget", _wrap_VariableElimination_isTarget, METH_VARARGS, "\n"
		"VariableElimination_isTarget(VariableElimination self, gum::NodeId const variable) -> bool\n"
		"VariableElimination_isTarget(VariableElimination self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : int\n"
		" a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variable is a (marginal) target\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "VariableElimination_nbrTargets", _wrap_VariableElimination_nbrTargets, METH_O, "\n"
		"VariableElimination_nbrTargets(VariableElimination self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "VariableElimination_H", _wrap_VariableElimination_H, METH_VARARGS, "\n"
		"VariableElimination_H(VariableElimination self, gum::NodeId const X) -> double\n"
		"VariableElimination_H(VariableElimination self, std::string const & nodeName) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "VariableElimination_evidenceImpact", _wrap_VariableElimination_evidenceImpact, METH_VARARGS, "\n"
		"VariableElimination_evidenceImpact(VariableElimination self, gum::NodeId target, PyObject * evs) -> Potential\n"
		"VariableElimination_evidenceImpact(VariableElimination self, std::string const & target, Vector_string evs) -> Potential\n"
		"\n"
		"Create a pyAgrum.Potential for P(target|evs) (for all instanciation of target and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : set\n"
		"  a set of targets ids or names.\n"
		"evs : set\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"if some evs are d-separated, they are not included in the Potential.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a Potential for P(targets|evs)\n"
		"\n"
		""},
	 { "VariableElimination_swigregister", VariableElimination_swigregister, METH_VARARGS, NULL},
	 { "VariableElimination_swiginit", VariableElimination_swiginit, METH_VARARGS, NULL},
	 { "new_GibbsSampling", _wrap_new_GibbsSampling, METH_O, "new_GibbsSampling(IBayesNet bn) -> GibbsSampling"},
	 { "delete_GibbsSampling", _wrap_delete_GibbsSampling, METH_O, "delete_GibbsSampling(GibbsSampling self)"},
	 { "GibbsSampling_setBurnIn", _wrap_GibbsSampling_setBurnIn, METH_VARARGS, "\n"
		"GibbsSampling_setBurnIn(GibbsSampling self, gum::Size b)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"b : int\n"
		"  size of burn in on number of iteration\n"
		"\n"
		""},
	 { "GibbsSampling_burnIn", _wrap_GibbsSampling_burnIn, METH_O, "\n"
		"GibbsSampling_burnIn(GibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  size of burn in on number of iteration\n"
		"\n"
		""},
	 { "GibbsSampling_setEvidence", _wrap_GibbsSampling_setEvidence, METH_VARARGS, "GibbsSampling_setEvidence(GibbsSampling self, PyObject * evidces)"},
	 { "GibbsSampling_updateEvidence", _wrap_GibbsSampling_updateEvidence, METH_VARARGS, "GibbsSampling_updateEvidence(GibbsSampling self, PyObject * evidces)"},
	 { "GibbsSampling_setTargets", _wrap_GibbsSampling_setTargets, METH_VARARGS, "GibbsSampling_setTargets(GibbsSampling self, PyObject * targets)"},
	 { "GibbsSampling_hardEvidenceNodes", _wrap_GibbsSampling_hardEvidenceNodes, METH_O, "\n"
		"GibbsSampling_hardEvidenceNodes(GibbsSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "GibbsSampling_softEvidenceNodes", _wrap_GibbsSampling_softEvidenceNodes, METH_O, "\n"
		"GibbsSampling_softEvidenceNodes(GibbsSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "GibbsSampling_targets", _wrap_GibbsSampling_targets, METH_O, "\n"
		"GibbsSampling_targets(GibbsSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "GibbsSampling_setVerbosity", _wrap_GibbsSampling_setVerbosity, METH_VARARGS, "\n"
		"GibbsSampling_setVerbosity(GibbsSampling self, bool v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "GibbsSampling_setEpsilon", _wrap_GibbsSampling_setEpsilon, METH_VARARGS, "\n"
		"GibbsSampling_setEpsilon(GibbsSampling self, double eps)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : double\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "GibbsSampling_setMinEpsilonRate", _wrap_GibbsSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"GibbsSampling_setMinEpsilonRate(GibbsSampling self, double rate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : double\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "GibbsSampling_setMaxIter", _wrap_GibbsSampling_setMaxIter, METH_VARARGS, "\n"
		"GibbsSampling_setMaxIter(GibbsSampling self, gum::Size max)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "GibbsSampling_setMaxTime", _wrap_GibbsSampling_setMaxTime, METH_VARARGS, "\n"
		"GibbsSampling_setMaxTime(GibbsSampling self, double timeout)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : double\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "GibbsSampling_setPeriodSize", _wrap_GibbsSampling_setPeriodSize, METH_VARARGS, "\n"
		"GibbsSampling_setPeriodSize(GibbsSampling self, gum::Size p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "GibbsSampling_verbosity", _wrap_GibbsSampling_verbosity, METH_O, "\n"
		"GibbsSampling_verbosity(GibbsSampling self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "GibbsSampling_epsilon", _wrap_GibbsSampling_epsilon, METH_O, "\n"
		"GibbsSampling_epsilon(GibbsSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "GibbsSampling_minEpsilonRate", _wrap_GibbsSampling_minEpsilonRate, METH_O, "\n"
		"GibbsSampling_minEpsilonRate(GibbsSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "GibbsSampling_maxIter", _wrap_GibbsSampling_maxIter, METH_O, "\n"
		"GibbsSampling_maxIter(GibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "GibbsSampling_maxTime", _wrap_GibbsSampling_maxTime, METH_O, "\n"
		"GibbsSampling_maxTime(GibbsSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "GibbsSampling_periodSize", _wrap_GibbsSampling_periodSize, METH_O, "\n"
		"GibbsSampling_periodSize(GibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "GibbsSampling_nbrIterations", _wrap_GibbsSampling_nbrIterations, METH_O, "\n"
		"GibbsSampling_nbrIterations(GibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "GibbsSampling_currentTime", _wrap_GibbsSampling_currentTime, METH_O, "\n"
		"GibbsSampling_currentTime(GibbsSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	get the current running time in second (double)\n"
		"\n"
		""},
	 { "GibbsSampling_messageApproximationScheme", _wrap_GibbsSampling_messageApproximationScheme, METH_O, "\n"
		"GibbsSampling_messageApproximationScheme(GibbsSampling self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "GibbsSampling_history", _wrap_GibbsSampling_history, METH_O, "\n"
		"GibbsSampling_history(GibbsSampling self) -> Vector\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "GibbsSampling_asIApproximationSchemeConfiguration", _wrap_GibbsSampling_asIApproximationSchemeConfiguration, METH_O, "\n"
		"GibbsSampling_asIApproximationSchemeConfiguration(GibbsSampling self) -> IApproximationSchemeConfiguration\n"
		"\n"
		"Returns\n"
		"-------\n"
		"asIApproximationSchemeConfiguration\n"
		"\n"
		""},
	 { "GibbsSampling_makeInference", _wrap_GibbsSampling_makeInference, METH_O, "\n"
		"GibbsSampling_makeInference(GibbsSampling self)\n"
		"\n"
		"Perform the heavy computations needed to compute the targets' posteriors\n"
		"\n"
		"In a Junction tree propagation scheme, for instance, the heavy computations are those of the messages sent in the JT.\n"
		"This is precisely what makeInference should compute. Later, the computations of the posteriors can be done 'lightly' by multiplying and projecting those messages.\n"
		"\n"
		""},
	 { "GibbsSampling_posterior", _wrap_GibbsSampling_posterior, METH_VARARGS, "\n"
		"GibbsSampling_posterior(GibbsSampling self, gum::NodeId const var) -> Potential\n"
		"GibbsSampling_posterior(GibbsSampling self, std::string const nodeName) -> Potential\n"
		"\n"
		"Computes and returns the posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "GibbsSampling_BN", _wrap_GibbsSampling_BN, METH_O, "\n"
		"GibbsSampling_BN(GibbsSampling self) -> IBayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "GibbsSampling_addEvidence", _wrap_GibbsSampling_addEvidence, METH_VARARGS, "\n"
		"GibbsSampling_addEvidence(GibbsSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"GibbsSampling_addEvidence(GibbsSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"GibbsSampling_addEvidence(GibbsSampling self, gum::NodeId const id, std::string const & val)\n"
		"GibbsSampling_addEvidence(GibbsSampling self, std::string const & nodeName, std::string const & val)\n"
		"GibbsSampling_addEvidence(GibbsSampling self, gum::NodeId const id, Vector vals)\n"
		"GibbsSampling_addEvidence(GibbsSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Adds a new evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node already has an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_chgEvidence", _wrap_GibbsSampling_chgEvidence, METH_VARARGS, "\n"
		"GibbsSampling_chgEvidence(GibbsSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"GibbsSampling_chgEvidence(GibbsSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"GibbsSampling_chgEvidence(GibbsSampling self, gum::NodeId const id, std::string const & val)\n"
		"GibbsSampling_chgEvidence(GibbsSampling self, std::string const & nodeName, std::string const & val)\n"
		"GibbsSampling_chgEvidence(GibbsSampling self, gum::NodeId const id, Vector vals)\n"
		"GibbsSampling_chgEvidence(GibbsSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Change the value of an already existing evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_hasEvidence", _wrap_GibbsSampling_hasEvidence, METH_VARARGS, "\n"
		"GibbsSampling_hasEvidence(GibbsSampling self, gum::NodeId const id) -> bool\n"
		"GibbsSampling_hasEvidence(GibbsSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if some node(s) (or the one in parameters) have received evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_eraseAllEvidence", _wrap_GibbsSampling_eraseAllEvidence, METH_O, "\n"
		"GibbsSampling_eraseAllEvidence(GibbsSampling self)\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "GibbsSampling_eraseEvidence", _wrap_GibbsSampling_eraseEvidence, METH_VARARGS, "\n"
		"GibbsSampling_eraseEvidence(GibbsSampling self, gum::NodeId const id)\n"
		"GibbsSampling_eraseEvidence(GibbsSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove the evidence, if any, corresponding to the node Id or name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_hasHardEvidence", _wrap_GibbsSampling_hasHardEvidence, METH_VARARGS, "\n"
		"GibbsSampling_hasHardEvidence(GibbsSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a hard evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_hasSoftEvidence", _wrap_GibbsSampling_hasSoftEvidence, METH_VARARGS, "\n"
		"GibbsSampling_hasSoftEvidence(GibbsSampling self, gum::NodeId const id) -> bool\n"
		"GibbsSampling_hasSoftEvidence(GibbsSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a soft evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_nbrEvidence", _wrap_GibbsSampling_nbrEvidence, METH_O, "\n"
		"GibbsSampling_nbrEvidence(GibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_nbrHardEvidence", _wrap_GibbsSampling_nbrHardEvidence, METH_O, "\n"
		"GibbsSampling_nbrHardEvidence(GibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of hard evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_nbrSoftEvidence", _wrap_GibbsSampling_nbrSoftEvidence, METH_O, "\n"
		"GibbsSampling_nbrSoftEvidence(GibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of soft evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_eraseAllTargets", _wrap_GibbsSampling_eraseAllTargets, METH_O, "\n"
		"GibbsSampling_eraseAllTargets(GibbsSampling self)\n"
		"\n"
		"Clear all previously defined targets (marginal and joint targets).\n"
		"\n"
		"As a result, no posterior can be computed (since we can only compute the posteriors of the marginal or joint targets that have been added by the user).\n"
		"\n"
		""},
	 { "GibbsSampling_addAllTargets", _wrap_GibbsSampling_addAllTargets, METH_O, "\n"
		"GibbsSampling_addAllTargets(GibbsSampling self)\n"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "GibbsSampling_addTarget", _wrap_GibbsSampling_addTarget, METH_VARARGS, "\n"
		"GibbsSampling_addTarget(GibbsSampling self, gum::NodeId const target)\n"
		"GibbsSampling_addTarget(GibbsSampling self, std::string const & nodeName)\n"
		"\n"
		"Add a marginal target to the list of targets.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "GibbsSampling_eraseTarget", _wrap_GibbsSampling_eraseTarget, METH_VARARGS, "\n"
		"GibbsSampling_eraseTarget(GibbsSampling self, gum::NodeId const target)\n"
		"GibbsSampling_eraseTarget(GibbsSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove, if existing, the marginal target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_isTarget", _wrap_GibbsSampling_isTarget, METH_VARARGS, "\n"
		"GibbsSampling_isTarget(GibbsSampling self, gum::NodeId const variable) -> bool\n"
		"GibbsSampling_isTarget(GibbsSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : int\n"
		" a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variable is a (marginal) target\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "GibbsSampling_nbrTargets", _wrap_GibbsSampling_nbrTargets, METH_O, "\n"
		"GibbsSampling_nbrTargets(GibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "GibbsSampling_H", _wrap_GibbsSampling_H, METH_VARARGS, "\n"
		"GibbsSampling_H(GibbsSampling self, gum::NodeId const X) -> double\n"
		"GibbsSampling_H(GibbsSampling self, std::string const & nodeName) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "GibbsSampling_evidenceImpact", _wrap_GibbsSampling_evidenceImpact, METH_VARARGS, "\n"
		"GibbsSampling_evidenceImpact(GibbsSampling self, gum::NodeId target, PyObject * evs) -> Potential\n"
		"GibbsSampling_evidenceImpact(GibbsSampling self, std::string const & target, Vector_string evs) -> Potential\n"
		"\n"
		"Create a pyAgrum.Potential for P(target|evs) (for all instanciation of target and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : set\n"
		"  a set of targets ids or names.\n"
		"evs : set\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"if some evs are d-separated, they are not included in the Potential.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a Potential for P(targets|evs)\n"
		"\n"
		""},
	 { "GibbsSampling_currentPosterior", _wrap_GibbsSampling_currentPosterior, METH_VARARGS, "\n"
		"GibbsSampling_currentPosterior(GibbsSampling self, gum::NodeId const id) -> Potential\n"
		"GibbsSampling_currentPosterior(GibbsSampling self, std::string const & name) -> Potential\n"
		"\n"
		"Computes and returns the current posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the current posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "GibbsSampling_nbrDrawnVar", _wrap_GibbsSampling_nbrDrawnVar, METH_O, "\n"
		"GibbsSampling_nbrDrawnVar(GibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of variable drawn at each iteration\n"
		"\n"
		""},
	 { "GibbsSampling_setNbrDrawnVar", _wrap_GibbsSampling_setNbrDrawnVar, METH_VARARGS, "\n"
		"GibbsSampling_setNbrDrawnVar(GibbsSampling self, gum::Size _nbr)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"_nbr : int\n"
		"  the number of variables to be drawn at each iteration\n"
		"\n"
		""},
	 { "GibbsSampling_isDrawnAtRandom", _wrap_GibbsSampling_isDrawnAtRandom, METH_O, "\n"
		"GibbsSampling_isDrawnAtRandom(GibbsSampling self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variables are drawn at random\n"
		"\n"
		""},
	 { "GibbsSampling_setDrawnAtRandom", _wrap_GibbsSampling_setDrawnAtRandom, METH_VARARGS, "\n"
		"GibbsSampling_setDrawnAtRandom(GibbsSampling self, bool _atRandom)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"_atRandom : bool\n"
		"  indicates if variables should be drawn at random\n"
		"\n"
		""},
	 { "GibbsSampling_swigregister", GibbsSampling_swigregister, METH_VARARGS, NULL},
	 { "GibbsSampling_swiginit", GibbsSampling_swiginit, METH_VARARGS, NULL},
	 { "new_ImportanceSampling", _wrap_new_ImportanceSampling, METH_O, "new_ImportanceSampling(IBayesNet bn) -> ImportanceSampling"},
	 { "delete_ImportanceSampling", _wrap_delete_ImportanceSampling, METH_O, "delete_ImportanceSampling(ImportanceSampling self)"},
	 { "ImportanceSampling_setEvidence", _wrap_ImportanceSampling_setEvidence, METH_VARARGS, "ImportanceSampling_setEvidence(ImportanceSampling self, PyObject * evidces)"},
	 { "ImportanceSampling_updateEvidence", _wrap_ImportanceSampling_updateEvidence, METH_VARARGS, "ImportanceSampling_updateEvidence(ImportanceSampling self, PyObject * evidces)"},
	 { "ImportanceSampling_setTargets", _wrap_ImportanceSampling_setTargets, METH_VARARGS, "ImportanceSampling_setTargets(ImportanceSampling self, PyObject * targets)"},
	 { "ImportanceSampling_hardEvidenceNodes", _wrap_ImportanceSampling_hardEvidenceNodes, METH_O, "\n"
		"ImportanceSampling_hardEvidenceNodes(ImportanceSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "ImportanceSampling_softEvidenceNodes", _wrap_ImportanceSampling_softEvidenceNodes, METH_O, "\n"
		"ImportanceSampling_softEvidenceNodes(ImportanceSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "ImportanceSampling_targets", _wrap_ImportanceSampling_targets, METH_O, "\n"
		"ImportanceSampling_targets(ImportanceSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "ImportanceSampling_setVerbosity", _wrap_ImportanceSampling_setVerbosity, METH_VARARGS, "\n"
		"ImportanceSampling_setVerbosity(ImportanceSampling self, bool v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "ImportanceSampling_setEpsilon", _wrap_ImportanceSampling_setEpsilon, METH_VARARGS, "\n"
		"ImportanceSampling_setEpsilon(ImportanceSampling self, double eps)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : double\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "ImportanceSampling_setMinEpsilonRate", _wrap_ImportanceSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"ImportanceSampling_setMinEpsilonRate(ImportanceSampling self, double rate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : double\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "ImportanceSampling_setMaxIter", _wrap_ImportanceSampling_setMaxIter, METH_VARARGS, "\n"
		"ImportanceSampling_setMaxIter(ImportanceSampling self, gum::Size max)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "ImportanceSampling_setMaxTime", _wrap_ImportanceSampling_setMaxTime, METH_VARARGS, "\n"
		"ImportanceSampling_setMaxTime(ImportanceSampling self, double timeout)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : double\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "ImportanceSampling_setPeriodSize", _wrap_ImportanceSampling_setPeriodSize, METH_VARARGS, "\n"
		"ImportanceSampling_setPeriodSize(ImportanceSampling self, gum::Size p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "ImportanceSampling_verbosity", _wrap_ImportanceSampling_verbosity, METH_O, "\n"
		"ImportanceSampling_verbosity(ImportanceSampling self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "ImportanceSampling_epsilon", _wrap_ImportanceSampling_epsilon, METH_O, "\n"
		"ImportanceSampling_epsilon(ImportanceSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "ImportanceSampling_minEpsilonRate", _wrap_ImportanceSampling_minEpsilonRate, METH_O, "\n"
		"ImportanceSampling_minEpsilonRate(ImportanceSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "ImportanceSampling_maxIter", _wrap_ImportanceSampling_maxIter, METH_O, "\n"
		"ImportanceSampling_maxIter(ImportanceSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "ImportanceSampling_maxTime", _wrap_ImportanceSampling_maxTime, METH_O, "\n"
		"ImportanceSampling_maxTime(ImportanceSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "ImportanceSampling_periodSize", _wrap_ImportanceSampling_periodSize, METH_O, "\n"
		"ImportanceSampling_periodSize(ImportanceSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "ImportanceSampling_nbrIterations", _wrap_ImportanceSampling_nbrIterations, METH_O, "\n"
		"ImportanceSampling_nbrIterations(ImportanceSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "ImportanceSampling_currentTime", _wrap_ImportanceSampling_currentTime, METH_O, "\n"
		"ImportanceSampling_currentTime(ImportanceSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	get the current running time in second (double)\n"
		"\n"
		""},
	 { "ImportanceSampling_messageApproximationScheme", _wrap_ImportanceSampling_messageApproximationScheme, METH_O, "\n"
		"ImportanceSampling_messageApproximationScheme(ImportanceSampling self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "ImportanceSampling_history", _wrap_ImportanceSampling_history, METH_O, "\n"
		"ImportanceSampling_history(ImportanceSampling self) -> Vector\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "ImportanceSampling_asIApproximationSchemeConfiguration", _wrap_ImportanceSampling_asIApproximationSchemeConfiguration, METH_O, "\n"
		"ImportanceSampling_asIApproximationSchemeConfiguration(ImportanceSampling self) -> IApproximationSchemeConfiguration\n"
		"\n"
		"Returns\n"
		"-------\n"
		"asIApproximationSchemeConfiguration\n"
		"\n"
		""},
	 { "ImportanceSampling_makeInference", _wrap_ImportanceSampling_makeInference, METH_O, "\n"
		"ImportanceSampling_makeInference(ImportanceSampling self)\n"
		"\n"
		"Perform the heavy computations needed to compute the targets' posteriors\n"
		"\n"
		"In a Junction tree propagation scheme, for instance, the heavy computations are those of the messages sent in the JT.\n"
		"This is precisely what makeInference should compute. Later, the computations of the posteriors can be done 'lightly' by multiplying and projecting those messages.\n"
		"\n"
		""},
	 { "ImportanceSampling_posterior", _wrap_ImportanceSampling_posterior, METH_VARARGS, "\n"
		"ImportanceSampling_posterior(ImportanceSampling self, gum::NodeId const var) -> Potential\n"
		"ImportanceSampling_posterior(ImportanceSampling self, std::string const nodeName) -> Potential\n"
		"\n"
		"Computes and returns the posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "ImportanceSampling_BN", _wrap_ImportanceSampling_BN, METH_O, "\n"
		"ImportanceSampling_BN(ImportanceSampling self) -> IBayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "ImportanceSampling_addEvidence", _wrap_ImportanceSampling_addEvidence, METH_VARARGS, "\n"
		"ImportanceSampling_addEvidence(ImportanceSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"ImportanceSampling_addEvidence(ImportanceSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"ImportanceSampling_addEvidence(ImportanceSampling self, gum::NodeId const id, std::string const & val)\n"
		"ImportanceSampling_addEvidence(ImportanceSampling self, std::string const & nodeName, std::string const & val)\n"
		"ImportanceSampling_addEvidence(ImportanceSampling self, gum::NodeId const id, Vector vals)\n"
		"ImportanceSampling_addEvidence(ImportanceSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Adds a new evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node already has an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_chgEvidence", _wrap_ImportanceSampling_chgEvidence, METH_VARARGS, "\n"
		"ImportanceSampling_chgEvidence(ImportanceSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"ImportanceSampling_chgEvidence(ImportanceSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"ImportanceSampling_chgEvidence(ImportanceSampling self, gum::NodeId const id, std::string const & val)\n"
		"ImportanceSampling_chgEvidence(ImportanceSampling self, std::string const & nodeName, std::string const & val)\n"
		"ImportanceSampling_chgEvidence(ImportanceSampling self, gum::NodeId const id, Vector vals)\n"
		"ImportanceSampling_chgEvidence(ImportanceSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Change the value of an already existing evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_hasEvidence", _wrap_ImportanceSampling_hasEvidence, METH_VARARGS, "\n"
		"ImportanceSampling_hasEvidence(ImportanceSampling self, gum::NodeId const id) -> bool\n"
		"ImportanceSampling_hasEvidence(ImportanceSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if some node(s) (or the one in parameters) have received evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_eraseAllEvidence", _wrap_ImportanceSampling_eraseAllEvidence, METH_O, "\n"
		"ImportanceSampling_eraseAllEvidence(ImportanceSampling self)\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "ImportanceSampling_eraseEvidence", _wrap_ImportanceSampling_eraseEvidence, METH_VARARGS, "\n"
		"ImportanceSampling_eraseEvidence(ImportanceSampling self, gum::NodeId const id)\n"
		"ImportanceSampling_eraseEvidence(ImportanceSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove the evidence, if any, corresponding to the node Id or name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_hasHardEvidence", _wrap_ImportanceSampling_hasHardEvidence, METH_VARARGS, "\n"
		"ImportanceSampling_hasHardEvidence(ImportanceSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a hard evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_hasSoftEvidence", _wrap_ImportanceSampling_hasSoftEvidence, METH_VARARGS, "\n"
		"ImportanceSampling_hasSoftEvidence(ImportanceSampling self, gum::NodeId const id) -> bool\n"
		"ImportanceSampling_hasSoftEvidence(ImportanceSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a soft evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_nbrEvidence", _wrap_ImportanceSampling_nbrEvidence, METH_O, "\n"
		"ImportanceSampling_nbrEvidence(ImportanceSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_nbrHardEvidence", _wrap_ImportanceSampling_nbrHardEvidence, METH_O, "\n"
		"ImportanceSampling_nbrHardEvidence(ImportanceSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of hard evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_nbrSoftEvidence", _wrap_ImportanceSampling_nbrSoftEvidence, METH_O, "\n"
		"ImportanceSampling_nbrSoftEvidence(ImportanceSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of soft evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_eraseAllTargets", _wrap_ImportanceSampling_eraseAllTargets, METH_O, "\n"
		"ImportanceSampling_eraseAllTargets(ImportanceSampling self)\n"
		"\n"
		"Clear all previously defined targets (marginal and joint targets).\n"
		"\n"
		"As a result, no posterior can be computed (since we can only compute the posteriors of the marginal or joint targets that have been added by the user).\n"
		"\n"
		""},
	 { "ImportanceSampling_addAllTargets", _wrap_ImportanceSampling_addAllTargets, METH_O, "\n"
		"ImportanceSampling_addAllTargets(ImportanceSampling self)\n"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "ImportanceSampling_addTarget", _wrap_ImportanceSampling_addTarget, METH_VARARGS, "\n"
		"ImportanceSampling_addTarget(ImportanceSampling self, gum::NodeId const target)\n"
		"ImportanceSampling_addTarget(ImportanceSampling self, std::string const & nodeName)\n"
		"\n"
		"Add a marginal target to the list of targets.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "ImportanceSampling_eraseTarget", _wrap_ImportanceSampling_eraseTarget, METH_VARARGS, "\n"
		"ImportanceSampling_eraseTarget(ImportanceSampling self, gum::NodeId const target)\n"
		"ImportanceSampling_eraseTarget(ImportanceSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove, if existing, the marginal target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_isTarget", _wrap_ImportanceSampling_isTarget, METH_VARARGS, "\n"
		"ImportanceSampling_isTarget(ImportanceSampling self, gum::NodeId const variable) -> bool\n"
		"ImportanceSampling_isTarget(ImportanceSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : int\n"
		" a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variable is a (marginal) target\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "ImportanceSampling_nbrTargets", _wrap_ImportanceSampling_nbrTargets, METH_O, "\n"
		"ImportanceSampling_nbrTargets(ImportanceSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "ImportanceSampling_H", _wrap_ImportanceSampling_H, METH_VARARGS, "\n"
		"ImportanceSampling_H(ImportanceSampling self, gum::NodeId const X) -> double\n"
		"ImportanceSampling_H(ImportanceSampling self, std::string const & nodeName) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "ImportanceSampling_evidenceImpact", _wrap_ImportanceSampling_evidenceImpact, METH_VARARGS, "\n"
		"ImportanceSampling_evidenceImpact(ImportanceSampling self, gum::NodeId target, PyObject * evs) -> Potential\n"
		"ImportanceSampling_evidenceImpact(ImportanceSampling self, std::string const & target, Vector_string evs) -> Potential\n"
		"\n"
		"Create a pyAgrum.Potential for P(target|evs) (for all instanciation of target and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : set\n"
		"  a set of targets ids or names.\n"
		"evs : set\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"if some evs are d-separated, they are not included in the Potential.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a Potential for P(targets|evs)\n"
		"\n"
		""},
	 { "ImportanceSampling_currentPosterior", _wrap_ImportanceSampling_currentPosterior, METH_VARARGS, "\n"
		"ImportanceSampling_currentPosterior(ImportanceSampling self, gum::NodeId const id) -> Potential\n"
		"ImportanceSampling_currentPosterior(ImportanceSampling self, std::string const & name) -> Potential\n"
		"\n"
		"Computes and returns the current posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the current posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "ImportanceSampling_swigregister", ImportanceSampling_swigregister, METH_VARARGS, NULL},
	 { "ImportanceSampling_swiginit", ImportanceSampling_swiginit, METH_VARARGS, NULL},
	 { "new_WeightedSampling", _wrap_new_WeightedSampling, METH_O, "new_WeightedSampling(IBayesNet bn) -> WeightedSampling"},
	 { "delete_WeightedSampling", _wrap_delete_WeightedSampling, METH_O, "delete_WeightedSampling(WeightedSampling self)"},
	 { "WeightedSampling_setEvidence", _wrap_WeightedSampling_setEvidence, METH_VARARGS, "WeightedSampling_setEvidence(WeightedSampling self, PyObject * evidces)"},
	 { "WeightedSampling_updateEvidence", _wrap_WeightedSampling_updateEvidence, METH_VARARGS, "WeightedSampling_updateEvidence(WeightedSampling self, PyObject * evidces)"},
	 { "WeightedSampling_setTargets", _wrap_WeightedSampling_setTargets, METH_VARARGS, "WeightedSampling_setTargets(WeightedSampling self, PyObject * targets)"},
	 { "WeightedSampling_hardEvidenceNodes", _wrap_WeightedSampling_hardEvidenceNodes, METH_O, "\n"
		"WeightedSampling_hardEvidenceNodes(WeightedSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "WeightedSampling_softEvidenceNodes", _wrap_WeightedSampling_softEvidenceNodes, METH_O, "\n"
		"WeightedSampling_softEvidenceNodes(WeightedSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "WeightedSampling_targets", _wrap_WeightedSampling_targets, METH_O, "\n"
		"WeightedSampling_targets(WeightedSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "WeightedSampling_setVerbosity", _wrap_WeightedSampling_setVerbosity, METH_VARARGS, "\n"
		"WeightedSampling_setVerbosity(WeightedSampling self, bool v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "WeightedSampling_setEpsilon", _wrap_WeightedSampling_setEpsilon, METH_VARARGS, "\n"
		"WeightedSampling_setEpsilon(WeightedSampling self, double eps)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : double\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "WeightedSampling_setMinEpsilonRate", _wrap_WeightedSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"WeightedSampling_setMinEpsilonRate(WeightedSampling self, double rate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : double\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "WeightedSampling_setMaxIter", _wrap_WeightedSampling_setMaxIter, METH_VARARGS, "\n"
		"WeightedSampling_setMaxIter(WeightedSampling self, gum::Size max)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "WeightedSampling_setMaxTime", _wrap_WeightedSampling_setMaxTime, METH_VARARGS, "\n"
		"WeightedSampling_setMaxTime(WeightedSampling self, double timeout)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : double\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "WeightedSampling_setPeriodSize", _wrap_WeightedSampling_setPeriodSize, METH_VARARGS, "\n"
		"WeightedSampling_setPeriodSize(WeightedSampling self, gum::Size p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "WeightedSampling_verbosity", _wrap_WeightedSampling_verbosity, METH_O, "\n"
		"WeightedSampling_verbosity(WeightedSampling self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "WeightedSampling_epsilon", _wrap_WeightedSampling_epsilon, METH_O, "\n"
		"WeightedSampling_epsilon(WeightedSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "WeightedSampling_minEpsilonRate", _wrap_WeightedSampling_minEpsilonRate, METH_O, "\n"
		"WeightedSampling_minEpsilonRate(WeightedSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "WeightedSampling_maxIter", _wrap_WeightedSampling_maxIter, METH_O, "\n"
		"WeightedSampling_maxIter(WeightedSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "WeightedSampling_maxTime", _wrap_WeightedSampling_maxTime, METH_O, "\n"
		"WeightedSampling_maxTime(WeightedSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "WeightedSampling_periodSize", _wrap_WeightedSampling_periodSize, METH_O, "\n"
		"WeightedSampling_periodSize(WeightedSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "WeightedSampling_nbrIterations", _wrap_WeightedSampling_nbrIterations, METH_O, "\n"
		"WeightedSampling_nbrIterations(WeightedSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "WeightedSampling_currentTime", _wrap_WeightedSampling_currentTime, METH_O, "\n"
		"WeightedSampling_currentTime(WeightedSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	get the current running time in second (double)\n"
		"\n"
		""},
	 { "WeightedSampling_messageApproximationScheme", _wrap_WeightedSampling_messageApproximationScheme, METH_O, "\n"
		"WeightedSampling_messageApproximationScheme(WeightedSampling self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "WeightedSampling_history", _wrap_WeightedSampling_history, METH_O, "\n"
		"WeightedSampling_history(WeightedSampling self) -> Vector\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "WeightedSampling_asIApproximationSchemeConfiguration", _wrap_WeightedSampling_asIApproximationSchemeConfiguration, METH_O, "\n"
		"WeightedSampling_asIApproximationSchemeConfiguration(WeightedSampling self) -> IApproximationSchemeConfiguration\n"
		"\n"
		"Returns\n"
		"-------\n"
		"asIApproximationSchemeConfiguration\n"
		"\n"
		""},
	 { "WeightedSampling_makeInference", _wrap_WeightedSampling_makeInference, METH_O, "\n"
		"WeightedSampling_makeInference(WeightedSampling self)\n"
		"\n"
		"Perform the heavy computations needed to compute the targets' posteriors\n"
		"\n"
		"In a Junction tree propagation scheme, for instance, the heavy computations are those of the messages sent in the JT.\n"
		"This is precisely what makeInference should compute. Later, the computations of the posteriors can be done 'lightly' by multiplying and projecting those messages.\n"
		"\n"
		""},
	 { "WeightedSampling_posterior", _wrap_WeightedSampling_posterior, METH_VARARGS, "\n"
		"WeightedSampling_posterior(WeightedSampling self, gum::NodeId const var) -> Potential\n"
		"WeightedSampling_posterior(WeightedSampling self, std::string const nodeName) -> Potential\n"
		"\n"
		"Computes and returns the posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "WeightedSampling_BN", _wrap_WeightedSampling_BN, METH_O, "\n"
		"WeightedSampling_BN(WeightedSampling self) -> IBayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "WeightedSampling_addEvidence", _wrap_WeightedSampling_addEvidence, METH_VARARGS, "\n"
		"WeightedSampling_addEvidence(WeightedSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"WeightedSampling_addEvidence(WeightedSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"WeightedSampling_addEvidence(WeightedSampling self, gum::NodeId const id, std::string const & val)\n"
		"WeightedSampling_addEvidence(WeightedSampling self, std::string const & nodeName, std::string const & val)\n"
		"WeightedSampling_addEvidence(WeightedSampling self, gum::NodeId const id, Vector vals)\n"
		"WeightedSampling_addEvidence(WeightedSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Adds a new evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node already has an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_chgEvidence", _wrap_WeightedSampling_chgEvidence, METH_VARARGS, "\n"
		"WeightedSampling_chgEvidence(WeightedSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"WeightedSampling_chgEvidence(WeightedSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"WeightedSampling_chgEvidence(WeightedSampling self, gum::NodeId const id, std::string const & val)\n"
		"WeightedSampling_chgEvidence(WeightedSampling self, std::string const & nodeName, std::string const & val)\n"
		"WeightedSampling_chgEvidence(WeightedSampling self, gum::NodeId const id, Vector vals)\n"
		"WeightedSampling_chgEvidence(WeightedSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Change the value of an already existing evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_hasEvidence", _wrap_WeightedSampling_hasEvidence, METH_VARARGS, "\n"
		"WeightedSampling_hasEvidence(WeightedSampling self, gum::NodeId const id) -> bool\n"
		"WeightedSampling_hasEvidence(WeightedSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if some node(s) (or the one in parameters) have received evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_eraseAllEvidence", _wrap_WeightedSampling_eraseAllEvidence, METH_O, "\n"
		"WeightedSampling_eraseAllEvidence(WeightedSampling self)\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "WeightedSampling_eraseEvidence", _wrap_WeightedSampling_eraseEvidence, METH_VARARGS, "\n"
		"WeightedSampling_eraseEvidence(WeightedSampling self, gum::NodeId const id)\n"
		"WeightedSampling_eraseEvidence(WeightedSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove the evidence, if any, corresponding to the node Id or name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_hasHardEvidence", _wrap_WeightedSampling_hasHardEvidence, METH_VARARGS, "\n"
		"WeightedSampling_hasHardEvidence(WeightedSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a hard evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_hasSoftEvidence", _wrap_WeightedSampling_hasSoftEvidence, METH_VARARGS, "\n"
		"WeightedSampling_hasSoftEvidence(WeightedSampling self, gum::NodeId const id) -> bool\n"
		"WeightedSampling_hasSoftEvidence(WeightedSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a soft evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_nbrEvidence", _wrap_WeightedSampling_nbrEvidence, METH_O, "\n"
		"WeightedSampling_nbrEvidence(WeightedSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_nbrHardEvidence", _wrap_WeightedSampling_nbrHardEvidence, METH_O, "\n"
		"WeightedSampling_nbrHardEvidence(WeightedSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of hard evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_nbrSoftEvidence", _wrap_WeightedSampling_nbrSoftEvidence, METH_O, "\n"
		"WeightedSampling_nbrSoftEvidence(WeightedSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of soft evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_eraseAllTargets", _wrap_WeightedSampling_eraseAllTargets, METH_O, "\n"
		"WeightedSampling_eraseAllTargets(WeightedSampling self)\n"
		"\n"
		"Clear all previously defined targets (marginal and joint targets).\n"
		"\n"
		"As a result, no posterior can be computed (since we can only compute the posteriors of the marginal or joint targets that have been added by the user).\n"
		"\n"
		""},
	 { "WeightedSampling_addAllTargets", _wrap_WeightedSampling_addAllTargets, METH_O, "\n"
		"WeightedSampling_addAllTargets(WeightedSampling self)\n"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "WeightedSampling_addTarget", _wrap_WeightedSampling_addTarget, METH_VARARGS, "\n"
		"WeightedSampling_addTarget(WeightedSampling self, gum::NodeId const target)\n"
		"WeightedSampling_addTarget(WeightedSampling self, std::string const & nodeName)\n"
		"\n"
		"Add a marginal target to the list of targets.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "WeightedSampling_eraseTarget", _wrap_WeightedSampling_eraseTarget, METH_VARARGS, "\n"
		"WeightedSampling_eraseTarget(WeightedSampling self, gum::NodeId const target)\n"
		"WeightedSampling_eraseTarget(WeightedSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove, if existing, the marginal target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_isTarget", _wrap_WeightedSampling_isTarget, METH_VARARGS, "\n"
		"WeightedSampling_isTarget(WeightedSampling self, gum::NodeId const variable) -> bool\n"
		"WeightedSampling_isTarget(WeightedSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : int\n"
		" a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variable is a (marginal) target\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "WeightedSampling_nbrTargets", _wrap_WeightedSampling_nbrTargets, METH_O, "\n"
		"WeightedSampling_nbrTargets(WeightedSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "WeightedSampling_H", _wrap_WeightedSampling_H, METH_VARARGS, "\n"
		"WeightedSampling_H(WeightedSampling self, gum::NodeId const X) -> double\n"
		"WeightedSampling_H(WeightedSampling self, std::string const & nodeName) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "WeightedSampling_evidenceImpact", _wrap_WeightedSampling_evidenceImpact, METH_VARARGS, "\n"
		"WeightedSampling_evidenceImpact(WeightedSampling self, gum::NodeId target, PyObject * evs) -> Potential\n"
		"WeightedSampling_evidenceImpact(WeightedSampling self, std::string const & target, Vector_string evs) -> Potential\n"
		"\n"
		"Create a pyAgrum.Potential for P(target|evs) (for all instanciation of target and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : set\n"
		"  a set of targets ids or names.\n"
		"evs : set\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"if some evs are d-separated, they are not included in the Potential.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a Potential for P(targets|evs)\n"
		"\n"
		""},
	 { "WeightedSampling_currentPosterior", _wrap_WeightedSampling_currentPosterior, METH_VARARGS, "\n"
		"WeightedSampling_currentPosterior(WeightedSampling self, gum::NodeId const id) -> Potential\n"
		"WeightedSampling_currentPosterior(WeightedSampling self, std::string const & name) -> Potential\n"
		"\n"
		"Computes and returns the current posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the current posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "WeightedSampling_swigregister", WeightedSampling_swigregister, METH_VARARGS, NULL},
	 { "WeightedSampling_swiginit", WeightedSampling_swiginit, METH_VARARGS, NULL},
	 { "new_MonteCarloSampling", _wrap_new_MonteCarloSampling, METH_O, "new_MonteCarloSampling(IBayesNet bn) -> MonteCarloSampling"},
	 { "delete_MonteCarloSampling", _wrap_delete_MonteCarloSampling, METH_O, "delete_MonteCarloSampling(MonteCarloSampling self)"},
	 { "MonteCarloSampling_setEvidence", _wrap_MonteCarloSampling_setEvidence, METH_VARARGS, "MonteCarloSampling_setEvidence(MonteCarloSampling self, PyObject * evidces)"},
	 { "MonteCarloSampling_updateEvidence", _wrap_MonteCarloSampling_updateEvidence, METH_VARARGS, "MonteCarloSampling_updateEvidence(MonteCarloSampling self, PyObject * evidces)"},
	 { "MonteCarloSampling_setTargets", _wrap_MonteCarloSampling_setTargets, METH_VARARGS, "MonteCarloSampling_setTargets(MonteCarloSampling self, PyObject * targets)"},
	 { "MonteCarloSampling_hardEvidenceNodes", _wrap_MonteCarloSampling_hardEvidenceNodes, METH_O, "\n"
		"MonteCarloSampling_hardEvidenceNodes(MonteCarloSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "MonteCarloSampling_softEvidenceNodes", _wrap_MonteCarloSampling_softEvidenceNodes, METH_O, "\n"
		"MonteCarloSampling_softEvidenceNodes(MonteCarloSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "MonteCarloSampling_targets", _wrap_MonteCarloSampling_targets, METH_O, "\n"
		"MonteCarloSampling_targets(MonteCarloSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "MonteCarloSampling_setVerbosity", _wrap_MonteCarloSampling_setVerbosity, METH_VARARGS, "\n"
		"MonteCarloSampling_setVerbosity(MonteCarloSampling self, bool v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "MonteCarloSampling_setEpsilon", _wrap_MonteCarloSampling_setEpsilon, METH_VARARGS, "\n"
		"MonteCarloSampling_setEpsilon(MonteCarloSampling self, double eps)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : double\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "MonteCarloSampling_setMinEpsilonRate", _wrap_MonteCarloSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"MonteCarloSampling_setMinEpsilonRate(MonteCarloSampling self, double rate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : double\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "MonteCarloSampling_setMaxIter", _wrap_MonteCarloSampling_setMaxIter, METH_VARARGS, "\n"
		"MonteCarloSampling_setMaxIter(MonteCarloSampling self, gum::Size max)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "MonteCarloSampling_setMaxTime", _wrap_MonteCarloSampling_setMaxTime, METH_VARARGS, "\n"
		"MonteCarloSampling_setMaxTime(MonteCarloSampling self, double timeout)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : double\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "MonteCarloSampling_setPeriodSize", _wrap_MonteCarloSampling_setPeriodSize, METH_VARARGS, "\n"
		"MonteCarloSampling_setPeriodSize(MonteCarloSampling self, gum::Size p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "MonteCarloSampling_verbosity", _wrap_MonteCarloSampling_verbosity, METH_O, "\n"
		"MonteCarloSampling_verbosity(MonteCarloSampling self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "MonteCarloSampling_epsilon", _wrap_MonteCarloSampling_epsilon, METH_O, "\n"
		"MonteCarloSampling_epsilon(MonteCarloSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "MonteCarloSampling_minEpsilonRate", _wrap_MonteCarloSampling_minEpsilonRate, METH_O, "\n"
		"MonteCarloSampling_minEpsilonRate(MonteCarloSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "MonteCarloSampling_maxIter", _wrap_MonteCarloSampling_maxIter, METH_O, "\n"
		"MonteCarloSampling_maxIter(MonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "MonteCarloSampling_maxTime", _wrap_MonteCarloSampling_maxTime, METH_O, "\n"
		"MonteCarloSampling_maxTime(MonteCarloSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "MonteCarloSampling_periodSize", _wrap_MonteCarloSampling_periodSize, METH_O, "\n"
		"MonteCarloSampling_periodSize(MonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "MonteCarloSampling_nbrIterations", _wrap_MonteCarloSampling_nbrIterations, METH_O, "\n"
		"MonteCarloSampling_nbrIterations(MonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "MonteCarloSampling_currentTime", _wrap_MonteCarloSampling_currentTime, METH_O, "\n"
		"MonteCarloSampling_currentTime(MonteCarloSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	get the current running time in second (double)\n"
		"\n"
		""},
	 { "MonteCarloSampling_messageApproximationScheme", _wrap_MonteCarloSampling_messageApproximationScheme, METH_O, "\n"
		"MonteCarloSampling_messageApproximationScheme(MonteCarloSampling self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "MonteCarloSampling_history", _wrap_MonteCarloSampling_history, METH_O, "\n"
		"MonteCarloSampling_history(MonteCarloSampling self) -> Vector\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "MonteCarloSampling_asIApproximationSchemeConfiguration", _wrap_MonteCarloSampling_asIApproximationSchemeConfiguration, METH_O, "\n"
		"MonteCarloSampling_asIApproximationSchemeConfiguration(MonteCarloSampling self) -> IApproximationSchemeConfiguration\n"
		"\n"
		"Returns\n"
		"-------\n"
		"asIApproximationSchemeConfiguration\n"
		"\n"
		""},
	 { "MonteCarloSampling_makeInference", _wrap_MonteCarloSampling_makeInference, METH_O, "\n"
		"MonteCarloSampling_makeInference(MonteCarloSampling self)\n"
		"\n"
		"Perform the heavy computations needed to compute the targets' posteriors\n"
		"\n"
		"In a Junction tree propagation scheme, for instance, the heavy computations are those of the messages sent in the JT.\n"
		"This is precisely what makeInference should compute. Later, the computations of the posteriors can be done 'lightly' by multiplying and projecting those messages.\n"
		"\n"
		""},
	 { "MonteCarloSampling_posterior", _wrap_MonteCarloSampling_posterior, METH_VARARGS, "\n"
		"MonteCarloSampling_posterior(MonteCarloSampling self, gum::NodeId const var) -> Potential\n"
		"MonteCarloSampling_posterior(MonteCarloSampling self, std::string const nodeName) -> Potential\n"
		"\n"
		"Computes and returns the posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "MonteCarloSampling_BN", _wrap_MonteCarloSampling_BN, METH_O, "\n"
		"MonteCarloSampling_BN(MonteCarloSampling self) -> IBayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "MonteCarloSampling_addEvidence", _wrap_MonteCarloSampling_addEvidence, METH_VARARGS, "\n"
		"MonteCarloSampling_addEvidence(MonteCarloSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"MonteCarloSampling_addEvidence(MonteCarloSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"MonteCarloSampling_addEvidence(MonteCarloSampling self, gum::NodeId const id, std::string const & val)\n"
		"MonteCarloSampling_addEvidence(MonteCarloSampling self, std::string const & nodeName, std::string const & val)\n"
		"MonteCarloSampling_addEvidence(MonteCarloSampling self, gum::NodeId const id, Vector vals)\n"
		"MonteCarloSampling_addEvidence(MonteCarloSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Adds a new evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node already has an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_chgEvidence", _wrap_MonteCarloSampling_chgEvidence, METH_VARARGS, "\n"
		"MonteCarloSampling_chgEvidence(MonteCarloSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"MonteCarloSampling_chgEvidence(MonteCarloSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"MonteCarloSampling_chgEvidence(MonteCarloSampling self, gum::NodeId const id, std::string const & val)\n"
		"MonteCarloSampling_chgEvidence(MonteCarloSampling self, std::string const & nodeName, std::string const & val)\n"
		"MonteCarloSampling_chgEvidence(MonteCarloSampling self, gum::NodeId const id, Vector vals)\n"
		"MonteCarloSampling_chgEvidence(MonteCarloSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Change the value of an already existing evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_hasEvidence", _wrap_MonteCarloSampling_hasEvidence, METH_VARARGS, "\n"
		"MonteCarloSampling_hasEvidence(MonteCarloSampling self, gum::NodeId const id) -> bool\n"
		"MonteCarloSampling_hasEvidence(MonteCarloSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if some node(s) (or the one in parameters) have received evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_eraseAllEvidence", _wrap_MonteCarloSampling_eraseAllEvidence, METH_O, "\n"
		"MonteCarloSampling_eraseAllEvidence(MonteCarloSampling self)\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "MonteCarloSampling_eraseEvidence", _wrap_MonteCarloSampling_eraseEvidence, METH_VARARGS, "\n"
		"MonteCarloSampling_eraseEvidence(MonteCarloSampling self, gum::NodeId const id)\n"
		"MonteCarloSampling_eraseEvidence(MonteCarloSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove the evidence, if any, corresponding to the node Id or name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_hasHardEvidence", _wrap_MonteCarloSampling_hasHardEvidence, METH_VARARGS, "\n"
		"MonteCarloSampling_hasHardEvidence(MonteCarloSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a hard evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_hasSoftEvidence", _wrap_MonteCarloSampling_hasSoftEvidence, METH_VARARGS, "\n"
		"MonteCarloSampling_hasSoftEvidence(MonteCarloSampling self, gum::NodeId const id) -> bool\n"
		"MonteCarloSampling_hasSoftEvidence(MonteCarloSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a soft evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_nbrEvidence", _wrap_MonteCarloSampling_nbrEvidence, METH_O, "\n"
		"MonteCarloSampling_nbrEvidence(MonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_nbrHardEvidence", _wrap_MonteCarloSampling_nbrHardEvidence, METH_O, "\n"
		"MonteCarloSampling_nbrHardEvidence(MonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of hard evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_nbrSoftEvidence", _wrap_MonteCarloSampling_nbrSoftEvidence, METH_O, "\n"
		"MonteCarloSampling_nbrSoftEvidence(MonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of soft evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_eraseAllTargets", _wrap_MonteCarloSampling_eraseAllTargets, METH_O, "\n"
		"MonteCarloSampling_eraseAllTargets(MonteCarloSampling self)\n"
		"\n"
		"Clear all previously defined targets (marginal and joint targets).\n"
		"\n"
		"As a result, no posterior can be computed (since we can only compute the posteriors of the marginal or joint targets that have been added by the user).\n"
		"\n"
		""},
	 { "MonteCarloSampling_addAllTargets", _wrap_MonteCarloSampling_addAllTargets, METH_O, "\n"
		"MonteCarloSampling_addAllTargets(MonteCarloSampling self)\n"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "MonteCarloSampling_addTarget", _wrap_MonteCarloSampling_addTarget, METH_VARARGS, "\n"
		"MonteCarloSampling_addTarget(MonteCarloSampling self, gum::NodeId const target)\n"
		"MonteCarloSampling_addTarget(MonteCarloSampling self, std::string const & nodeName)\n"
		"\n"
		"Add a marginal target to the list of targets.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "MonteCarloSampling_eraseTarget", _wrap_MonteCarloSampling_eraseTarget, METH_VARARGS, "\n"
		"MonteCarloSampling_eraseTarget(MonteCarloSampling self, gum::NodeId const target)\n"
		"MonteCarloSampling_eraseTarget(MonteCarloSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove, if existing, the marginal target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_isTarget", _wrap_MonteCarloSampling_isTarget, METH_VARARGS, "\n"
		"MonteCarloSampling_isTarget(MonteCarloSampling self, gum::NodeId const variable) -> bool\n"
		"MonteCarloSampling_isTarget(MonteCarloSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : int\n"
		" a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variable is a (marginal) target\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "MonteCarloSampling_nbrTargets", _wrap_MonteCarloSampling_nbrTargets, METH_O, "\n"
		"MonteCarloSampling_nbrTargets(MonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "MonteCarloSampling_H", _wrap_MonteCarloSampling_H, METH_VARARGS, "\n"
		"MonteCarloSampling_H(MonteCarloSampling self, gum::NodeId const X) -> double\n"
		"MonteCarloSampling_H(MonteCarloSampling self, std::string const & nodeName) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "MonteCarloSampling_evidenceImpact", _wrap_MonteCarloSampling_evidenceImpact, METH_VARARGS, "\n"
		"MonteCarloSampling_evidenceImpact(MonteCarloSampling self, gum::NodeId target, PyObject * evs) -> Potential\n"
		"MonteCarloSampling_evidenceImpact(MonteCarloSampling self, std::string const & target, Vector_string evs) -> Potential\n"
		"\n"
		"Create a pyAgrum.Potential for P(target|evs) (for all instanciation of target and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : set\n"
		"  a set of targets ids or names.\n"
		"evs : set\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"if some evs are d-separated, they are not included in the Potential.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a Potential for P(targets|evs)\n"
		"\n"
		""},
	 { "MonteCarloSampling_currentPosterior", _wrap_MonteCarloSampling_currentPosterior, METH_VARARGS, "\n"
		"MonteCarloSampling_currentPosterior(MonteCarloSampling self, gum::NodeId const id) -> Potential\n"
		"MonteCarloSampling_currentPosterior(MonteCarloSampling self, std::string const & name) -> Potential\n"
		"\n"
		"Computes and returns the current posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the current posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "MonteCarloSampling_swigregister", MonteCarloSampling_swigregister, METH_VARARGS, NULL},
	 { "MonteCarloSampling_swiginit", MonteCarloSampling_swiginit, METH_VARARGS, NULL},
	 { "new_LoopyImportanceSampling", _wrap_new_LoopyImportanceSampling, METH_O, "new_LoopyImportanceSampling(IBayesNet bn) -> LoopyImportanceSampling"},
	 { "delete_LoopyImportanceSampling", _wrap_delete_LoopyImportanceSampling, METH_O, "delete_LoopyImportanceSampling(LoopyImportanceSampling self)"},
	 { "LoopyImportanceSampling__makeInference", _wrap_LoopyImportanceSampling__makeInference, METH_O, "LoopyImportanceSampling__makeInference(LoopyImportanceSampling self)"},
	 { "LoopyImportanceSampling_setVirtualLBPSize", _wrap_LoopyImportanceSampling_setVirtualLBPSize, METH_VARARGS, "\n"
		"LoopyImportanceSampling_setVirtualLBPSize(LoopyImportanceSampling self, double vlbpsize)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"vlbpsize : double\n"
		"  the size of the virtual LBP\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_setEvidence", _wrap_LoopyImportanceSampling_setEvidence, METH_VARARGS, "LoopyImportanceSampling_setEvidence(LoopyImportanceSampling self, PyObject * evidces)"},
	 { "LoopyImportanceSampling_updateEvidence", _wrap_LoopyImportanceSampling_updateEvidence, METH_VARARGS, "LoopyImportanceSampling_updateEvidence(LoopyImportanceSampling self, PyObject * evidces)"},
	 { "LoopyImportanceSampling_setTargets", _wrap_LoopyImportanceSampling_setTargets, METH_VARARGS, "LoopyImportanceSampling_setTargets(LoopyImportanceSampling self, PyObject * targets)"},
	 { "LoopyImportanceSampling_hardEvidenceNodes", _wrap_LoopyImportanceSampling_hardEvidenceNodes, METH_O, "\n"
		"LoopyImportanceSampling_hardEvidenceNodes(LoopyImportanceSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_softEvidenceNodes", _wrap_LoopyImportanceSampling_softEvidenceNodes, METH_O, "\n"
		"LoopyImportanceSampling_softEvidenceNodes(LoopyImportanceSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_targets", _wrap_LoopyImportanceSampling_targets, METH_O, "\n"
		"LoopyImportanceSampling_targets(LoopyImportanceSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_setVerbosity", _wrap_LoopyImportanceSampling_setVerbosity, METH_VARARGS, "\n"
		"LoopyImportanceSampling_setVerbosity(LoopyImportanceSampling self, bool v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_setEpsilon", _wrap_LoopyImportanceSampling_setEpsilon, METH_VARARGS, "\n"
		"LoopyImportanceSampling_setEpsilon(LoopyImportanceSampling self, double eps)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : double\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_setMinEpsilonRate", _wrap_LoopyImportanceSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"LoopyImportanceSampling_setMinEpsilonRate(LoopyImportanceSampling self, double rate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : double\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_setMaxIter", _wrap_LoopyImportanceSampling_setMaxIter, METH_VARARGS, "\n"
		"LoopyImportanceSampling_setMaxIter(LoopyImportanceSampling self, gum::Size max)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_setMaxTime", _wrap_LoopyImportanceSampling_setMaxTime, METH_VARARGS, "\n"
		"LoopyImportanceSampling_setMaxTime(LoopyImportanceSampling self, double timeout)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : double\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_setPeriodSize", _wrap_LoopyImportanceSampling_setPeriodSize, METH_VARARGS, "\n"
		"LoopyImportanceSampling_setPeriodSize(LoopyImportanceSampling self, gum::Size p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_verbosity", _wrap_LoopyImportanceSampling_verbosity, METH_O, "\n"
		"LoopyImportanceSampling_verbosity(LoopyImportanceSampling self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_epsilon", _wrap_LoopyImportanceSampling_epsilon, METH_O, "\n"
		"LoopyImportanceSampling_epsilon(LoopyImportanceSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_minEpsilonRate", _wrap_LoopyImportanceSampling_minEpsilonRate, METH_O, "\n"
		"LoopyImportanceSampling_minEpsilonRate(LoopyImportanceSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_maxIter", _wrap_LoopyImportanceSampling_maxIter, METH_O, "\n"
		"LoopyImportanceSampling_maxIter(LoopyImportanceSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_maxTime", _wrap_LoopyImportanceSampling_maxTime, METH_O, "\n"
		"LoopyImportanceSampling_maxTime(LoopyImportanceSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_periodSize", _wrap_LoopyImportanceSampling_periodSize, METH_O, "\n"
		"LoopyImportanceSampling_periodSize(LoopyImportanceSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_nbrIterations", _wrap_LoopyImportanceSampling_nbrIterations, METH_O, "\n"
		"LoopyImportanceSampling_nbrIterations(LoopyImportanceSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_currentTime", _wrap_LoopyImportanceSampling_currentTime, METH_O, "\n"
		"LoopyImportanceSampling_currentTime(LoopyImportanceSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	get the current running time in second (double)\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_messageApproximationScheme", _wrap_LoopyImportanceSampling_messageApproximationScheme, METH_O, "\n"
		"LoopyImportanceSampling_messageApproximationScheme(LoopyImportanceSampling self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_history", _wrap_LoopyImportanceSampling_history, METH_O, "\n"
		"LoopyImportanceSampling_history(LoopyImportanceSampling self) -> Vector\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_asIApproximationSchemeConfiguration", _wrap_LoopyImportanceSampling_asIApproximationSchemeConfiguration, METH_O, "\n"
		"LoopyImportanceSampling_asIApproximationSchemeConfiguration(LoopyImportanceSampling self) -> IApproximationSchemeConfiguration\n"
		"\n"
		"Returns\n"
		"-------\n"
		"asIApproximationSchemeConfiguration\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_makeInference", _wrap_LoopyImportanceSampling_makeInference, METH_O, "\n"
		"LoopyImportanceSampling_makeInference(LoopyImportanceSampling self)\n"
		"\n"
		"Perform the heavy computations needed to compute the targets' posteriors\n"
		"\n"
		"In a Junction tree propagation scheme, for instance, the heavy computations are those of the messages sent in the JT.\n"
		"This is precisely what makeInference should compute. Later, the computations of the posteriors can be done 'lightly' by multiplying and projecting those messages.\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_posterior", _wrap_LoopyImportanceSampling_posterior, METH_VARARGS, "\n"
		"LoopyImportanceSampling_posterior(LoopyImportanceSampling self, gum::NodeId const var) -> Potential\n"
		"LoopyImportanceSampling_posterior(LoopyImportanceSampling self, std::string const nodeName) -> Potential\n"
		"\n"
		"Computes and returns the posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_BN", _wrap_LoopyImportanceSampling_BN, METH_O, "\n"
		"LoopyImportanceSampling_BN(LoopyImportanceSampling self) -> IBayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_addEvidence", _wrap_LoopyImportanceSampling_addEvidence, METH_VARARGS, "\n"
		"LoopyImportanceSampling_addEvidence(LoopyImportanceSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"LoopyImportanceSampling_addEvidence(LoopyImportanceSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"LoopyImportanceSampling_addEvidence(LoopyImportanceSampling self, gum::NodeId const id, std::string const & val)\n"
		"LoopyImportanceSampling_addEvidence(LoopyImportanceSampling self, std::string const & nodeName, std::string const & val)\n"
		"LoopyImportanceSampling_addEvidence(LoopyImportanceSampling self, gum::NodeId const id, Vector vals)\n"
		"LoopyImportanceSampling_addEvidence(LoopyImportanceSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Adds a new evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node already has an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_chgEvidence", _wrap_LoopyImportanceSampling_chgEvidence, METH_VARARGS, "\n"
		"LoopyImportanceSampling_chgEvidence(LoopyImportanceSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"LoopyImportanceSampling_chgEvidence(LoopyImportanceSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"LoopyImportanceSampling_chgEvidence(LoopyImportanceSampling self, gum::NodeId const id, std::string const & val)\n"
		"LoopyImportanceSampling_chgEvidence(LoopyImportanceSampling self, std::string const & nodeName, std::string const & val)\n"
		"LoopyImportanceSampling_chgEvidence(LoopyImportanceSampling self, gum::NodeId const id, Vector vals)\n"
		"LoopyImportanceSampling_chgEvidence(LoopyImportanceSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Change the value of an already existing evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_hasEvidence", _wrap_LoopyImportanceSampling_hasEvidence, METH_VARARGS, "\n"
		"LoopyImportanceSampling_hasEvidence(LoopyImportanceSampling self, gum::NodeId const id) -> bool\n"
		"LoopyImportanceSampling_hasEvidence(LoopyImportanceSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if some node(s) (or the one in parameters) have received evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_eraseAllEvidence", _wrap_LoopyImportanceSampling_eraseAllEvidence, METH_O, "\n"
		"LoopyImportanceSampling_eraseAllEvidence(LoopyImportanceSampling self)\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_eraseEvidence", _wrap_LoopyImportanceSampling_eraseEvidence, METH_VARARGS, "\n"
		"LoopyImportanceSampling_eraseEvidence(LoopyImportanceSampling self, gum::NodeId const id)\n"
		"LoopyImportanceSampling_eraseEvidence(LoopyImportanceSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove the evidence, if any, corresponding to the node Id or name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_hasHardEvidence", _wrap_LoopyImportanceSampling_hasHardEvidence, METH_VARARGS, "\n"
		"LoopyImportanceSampling_hasHardEvidence(LoopyImportanceSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a hard evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_hasSoftEvidence", _wrap_LoopyImportanceSampling_hasSoftEvidence, METH_VARARGS, "\n"
		"LoopyImportanceSampling_hasSoftEvidence(LoopyImportanceSampling self, gum::NodeId const id) -> bool\n"
		"LoopyImportanceSampling_hasSoftEvidence(LoopyImportanceSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a soft evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_nbrEvidence", _wrap_LoopyImportanceSampling_nbrEvidence, METH_O, "\n"
		"LoopyImportanceSampling_nbrEvidence(LoopyImportanceSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_nbrHardEvidence", _wrap_LoopyImportanceSampling_nbrHardEvidence, METH_O, "\n"
		"LoopyImportanceSampling_nbrHardEvidence(LoopyImportanceSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of hard evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_nbrSoftEvidence", _wrap_LoopyImportanceSampling_nbrSoftEvidence, METH_O, "\n"
		"LoopyImportanceSampling_nbrSoftEvidence(LoopyImportanceSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of soft evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_eraseAllTargets", _wrap_LoopyImportanceSampling_eraseAllTargets, METH_O, "\n"
		"LoopyImportanceSampling_eraseAllTargets(LoopyImportanceSampling self)\n"
		"\n"
		"Clear all previously defined targets (marginal and joint targets).\n"
		"\n"
		"As a result, no posterior can be computed (since we can only compute the posteriors of the marginal or joint targets that have been added by the user).\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_addAllTargets", _wrap_LoopyImportanceSampling_addAllTargets, METH_O, "\n"
		"LoopyImportanceSampling_addAllTargets(LoopyImportanceSampling self)\n"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_addTarget", _wrap_LoopyImportanceSampling_addTarget, METH_VARARGS, "\n"
		"LoopyImportanceSampling_addTarget(LoopyImportanceSampling self, gum::NodeId const target)\n"
		"LoopyImportanceSampling_addTarget(LoopyImportanceSampling self, std::string const & nodeName)\n"
		"\n"
		"Add a marginal target to the list of targets.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_eraseTarget", _wrap_LoopyImportanceSampling_eraseTarget, METH_VARARGS, "\n"
		"LoopyImportanceSampling_eraseTarget(LoopyImportanceSampling self, gum::NodeId const target)\n"
		"LoopyImportanceSampling_eraseTarget(LoopyImportanceSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove, if existing, the marginal target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_isTarget", _wrap_LoopyImportanceSampling_isTarget, METH_VARARGS, "\n"
		"LoopyImportanceSampling_isTarget(LoopyImportanceSampling self, gum::NodeId const variable) -> bool\n"
		"LoopyImportanceSampling_isTarget(LoopyImportanceSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : int\n"
		" a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variable is a (marginal) target\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_nbrTargets", _wrap_LoopyImportanceSampling_nbrTargets, METH_O, "\n"
		"LoopyImportanceSampling_nbrTargets(LoopyImportanceSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_H", _wrap_LoopyImportanceSampling_H, METH_VARARGS, "\n"
		"LoopyImportanceSampling_H(LoopyImportanceSampling self, gum::NodeId const X) -> double\n"
		"LoopyImportanceSampling_H(LoopyImportanceSampling self, std::string const & nodeName) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_evidenceImpact", _wrap_LoopyImportanceSampling_evidenceImpact, METH_VARARGS, "\n"
		"LoopyImportanceSampling_evidenceImpact(LoopyImportanceSampling self, gum::NodeId target, PyObject * evs) -> Potential\n"
		"LoopyImportanceSampling_evidenceImpact(LoopyImportanceSampling self, std::string const & target, Vector_string evs) -> Potential\n"
		"\n"
		"Create a pyAgrum.Potential for P(target|evs) (for all instanciation of target and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : set\n"
		"  a set of targets ids or names.\n"
		"evs : set\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"if some evs are d-separated, they are not included in the Potential.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a Potential for P(targets|evs)\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_currentPosterior", _wrap_LoopyImportanceSampling_currentPosterior, METH_VARARGS, "\n"
		"LoopyImportanceSampling_currentPosterior(LoopyImportanceSampling self, gum::NodeId const id) -> Potential\n"
		"LoopyImportanceSampling_currentPosterior(LoopyImportanceSampling self, std::string const & name) -> Potential\n"
		"\n"
		"Computes and returns the current posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the current posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LoopyImportanceSampling_swigregister", LoopyImportanceSampling_swigregister, METH_VARARGS, NULL},
	 { "LoopyImportanceSampling_swiginit", LoopyImportanceSampling_swiginit, METH_VARARGS, NULL},
	 { "new_LoopyWeightedSampling", _wrap_new_LoopyWeightedSampling, METH_O, "new_LoopyWeightedSampling(IBayesNet bn) -> LoopyWeightedSampling"},
	 { "delete_LoopyWeightedSampling", _wrap_delete_LoopyWeightedSampling, METH_O, "delete_LoopyWeightedSampling(LoopyWeightedSampling self)"},
	 { "LoopyWeightedSampling__makeInference", _wrap_LoopyWeightedSampling__makeInference, METH_O, "LoopyWeightedSampling__makeInference(LoopyWeightedSampling self)"},
	 { "LoopyWeightedSampling_setVirtualLBPSize", _wrap_LoopyWeightedSampling_setVirtualLBPSize, METH_VARARGS, "\n"
		"LoopyWeightedSampling_setVirtualLBPSize(LoopyWeightedSampling self, double vlbpsize)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"vlbpsize : double\n"
		"  the size of the virtual LBP\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_setEvidence", _wrap_LoopyWeightedSampling_setEvidence, METH_VARARGS, "LoopyWeightedSampling_setEvidence(LoopyWeightedSampling self, PyObject * evidces)"},
	 { "LoopyWeightedSampling_updateEvidence", _wrap_LoopyWeightedSampling_updateEvidence, METH_VARARGS, "LoopyWeightedSampling_updateEvidence(LoopyWeightedSampling self, PyObject * evidces)"},
	 { "LoopyWeightedSampling_setTargets", _wrap_LoopyWeightedSampling_setTargets, METH_VARARGS, "LoopyWeightedSampling_setTargets(LoopyWeightedSampling self, PyObject * targets)"},
	 { "LoopyWeightedSampling_hardEvidenceNodes", _wrap_LoopyWeightedSampling_hardEvidenceNodes, METH_O, "\n"
		"LoopyWeightedSampling_hardEvidenceNodes(LoopyWeightedSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_softEvidenceNodes", _wrap_LoopyWeightedSampling_softEvidenceNodes, METH_O, "\n"
		"LoopyWeightedSampling_softEvidenceNodes(LoopyWeightedSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_targets", _wrap_LoopyWeightedSampling_targets, METH_O, "\n"
		"LoopyWeightedSampling_targets(LoopyWeightedSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_setVerbosity", _wrap_LoopyWeightedSampling_setVerbosity, METH_VARARGS, "\n"
		"LoopyWeightedSampling_setVerbosity(LoopyWeightedSampling self, bool v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_setEpsilon", _wrap_LoopyWeightedSampling_setEpsilon, METH_VARARGS, "\n"
		"LoopyWeightedSampling_setEpsilon(LoopyWeightedSampling self, double eps)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : double\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_setMinEpsilonRate", _wrap_LoopyWeightedSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"LoopyWeightedSampling_setMinEpsilonRate(LoopyWeightedSampling self, double rate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : double\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_setMaxIter", _wrap_LoopyWeightedSampling_setMaxIter, METH_VARARGS, "\n"
		"LoopyWeightedSampling_setMaxIter(LoopyWeightedSampling self, gum::Size max)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_setMaxTime", _wrap_LoopyWeightedSampling_setMaxTime, METH_VARARGS, "\n"
		"LoopyWeightedSampling_setMaxTime(LoopyWeightedSampling self, double timeout)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : double\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_setPeriodSize", _wrap_LoopyWeightedSampling_setPeriodSize, METH_VARARGS, "\n"
		"LoopyWeightedSampling_setPeriodSize(LoopyWeightedSampling self, gum::Size p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_verbosity", _wrap_LoopyWeightedSampling_verbosity, METH_O, "\n"
		"LoopyWeightedSampling_verbosity(LoopyWeightedSampling self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_epsilon", _wrap_LoopyWeightedSampling_epsilon, METH_O, "\n"
		"LoopyWeightedSampling_epsilon(LoopyWeightedSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_minEpsilonRate", _wrap_LoopyWeightedSampling_minEpsilonRate, METH_O, "\n"
		"LoopyWeightedSampling_minEpsilonRate(LoopyWeightedSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_maxIter", _wrap_LoopyWeightedSampling_maxIter, METH_O, "\n"
		"LoopyWeightedSampling_maxIter(LoopyWeightedSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_maxTime", _wrap_LoopyWeightedSampling_maxTime, METH_O, "\n"
		"LoopyWeightedSampling_maxTime(LoopyWeightedSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_periodSize", _wrap_LoopyWeightedSampling_periodSize, METH_O, "\n"
		"LoopyWeightedSampling_periodSize(LoopyWeightedSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_nbrIterations", _wrap_LoopyWeightedSampling_nbrIterations, METH_O, "\n"
		"LoopyWeightedSampling_nbrIterations(LoopyWeightedSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_currentTime", _wrap_LoopyWeightedSampling_currentTime, METH_O, "\n"
		"LoopyWeightedSampling_currentTime(LoopyWeightedSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	get the current running time in second (double)\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_messageApproximationScheme", _wrap_LoopyWeightedSampling_messageApproximationScheme, METH_O, "\n"
		"LoopyWeightedSampling_messageApproximationScheme(LoopyWeightedSampling self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_history", _wrap_LoopyWeightedSampling_history, METH_O, "\n"
		"LoopyWeightedSampling_history(LoopyWeightedSampling self) -> Vector\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_asIApproximationSchemeConfiguration", _wrap_LoopyWeightedSampling_asIApproximationSchemeConfiguration, METH_O, "\n"
		"LoopyWeightedSampling_asIApproximationSchemeConfiguration(LoopyWeightedSampling self) -> IApproximationSchemeConfiguration\n"
		"\n"
		"Returns\n"
		"-------\n"
		"asIApproximationSchemeConfiguration\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_makeInference", _wrap_LoopyWeightedSampling_makeInference, METH_O, "\n"
		"LoopyWeightedSampling_makeInference(LoopyWeightedSampling self)\n"
		"\n"
		"Perform the heavy computations needed to compute the targets' posteriors\n"
		"\n"
		"In a Junction tree propagation scheme, for instance, the heavy computations are those of the messages sent in the JT.\n"
		"This is precisely what makeInference should compute. Later, the computations of the posteriors can be done 'lightly' by multiplying and projecting those messages.\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_posterior", _wrap_LoopyWeightedSampling_posterior, METH_VARARGS, "\n"
		"LoopyWeightedSampling_posterior(LoopyWeightedSampling self, gum::NodeId const var) -> Potential\n"
		"LoopyWeightedSampling_posterior(LoopyWeightedSampling self, std::string const nodeName) -> Potential\n"
		"\n"
		"Computes and returns the posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_BN", _wrap_LoopyWeightedSampling_BN, METH_O, "\n"
		"LoopyWeightedSampling_BN(LoopyWeightedSampling self) -> IBayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_addEvidence", _wrap_LoopyWeightedSampling_addEvidence, METH_VARARGS, "\n"
		"LoopyWeightedSampling_addEvidence(LoopyWeightedSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"LoopyWeightedSampling_addEvidence(LoopyWeightedSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"LoopyWeightedSampling_addEvidence(LoopyWeightedSampling self, gum::NodeId const id, std::string const & val)\n"
		"LoopyWeightedSampling_addEvidence(LoopyWeightedSampling self, std::string const & nodeName, std::string const & val)\n"
		"LoopyWeightedSampling_addEvidence(LoopyWeightedSampling self, gum::NodeId const id, Vector vals)\n"
		"LoopyWeightedSampling_addEvidence(LoopyWeightedSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Adds a new evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node already has an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_chgEvidence", _wrap_LoopyWeightedSampling_chgEvidence, METH_VARARGS, "\n"
		"LoopyWeightedSampling_chgEvidence(LoopyWeightedSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"LoopyWeightedSampling_chgEvidence(LoopyWeightedSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"LoopyWeightedSampling_chgEvidence(LoopyWeightedSampling self, gum::NodeId const id, std::string const & val)\n"
		"LoopyWeightedSampling_chgEvidence(LoopyWeightedSampling self, std::string const & nodeName, std::string const & val)\n"
		"LoopyWeightedSampling_chgEvidence(LoopyWeightedSampling self, gum::NodeId const id, Vector vals)\n"
		"LoopyWeightedSampling_chgEvidence(LoopyWeightedSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Change the value of an already existing evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_hasEvidence", _wrap_LoopyWeightedSampling_hasEvidence, METH_VARARGS, "\n"
		"LoopyWeightedSampling_hasEvidence(LoopyWeightedSampling self, gum::NodeId const id) -> bool\n"
		"LoopyWeightedSampling_hasEvidence(LoopyWeightedSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if some node(s) (or the one in parameters) have received evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_eraseAllEvidence", _wrap_LoopyWeightedSampling_eraseAllEvidence, METH_O, "\n"
		"LoopyWeightedSampling_eraseAllEvidence(LoopyWeightedSampling self)\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_eraseEvidence", _wrap_LoopyWeightedSampling_eraseEvidence, METH_VARARGS, "\n"
		"LoopyWeightedSampling_eraseEvidence(LoopyWeightedSampling self, gum::NodeId const id)\n"
		"LoopyWeightedSampling_eraseEvidence(LoopyWeightedSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove the evidence, if any, corresponding to the node Id or name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_hasHardEvidence", _wrap_LoopyWeightedSampling_hasHardEvidence, METH_VARARGS, "\n"
		"LoopyWeightedSampling_hasHardEvidence(LoopyWeightedSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a hard evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_hasSoftEvidence", _wrap_LoopyWeightedSampling_hasSoftEvidence, METH_VARARGS, "\n"
		"LoopyWeightedSampling_hasSoftEvidence(LoopyWeightedSampling self, gum::NodeId const id) -> bool\n"
		"LoopyWeightedSampling_hasSoftEvidence(LoopyWeightedSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a soft evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_nbrEvidence", _wrap_LoopyWeightedSampling_nbrEvidence, METH_O, "\n"
		"LoopyWeightedSampling_nbrEvidence(LoopyWeightedSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_nbrHardEvidence", _wrap_LoopyWeightedSampling_nbrHardEvidence, METH_O, "\n"
		"LoopyWeightedSampling_nbrHardEvidence(LoopyWeightedSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of hard evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_nbrSoftEvidence", _wrap_LoopyWeightedSampling_nbrSoftEvidence, METH_O, "\n"
		"LoopyWeightedSampling_nbrSoftEvidence(LoopyWeightedSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of soft evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_eraseAllTargets", _wrap_LoopyWeightedSampling_eraseAllTargets, METH_O, "\n"
		"LoopyWeightedSampling_eraseAllTargets(LoopyWeightedSampling self)\n"
		"\n"
		"Clear all previously defined targets (marginal and joint targets).\n"
		"\n"
		"As a result, no posterior can be computed (since we can only compute the posteriors of the marginal or joint targets that have been added by the user).\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_addAllTargets", _wrap_LoopyWeightedSampling_addAllTargets, METH_O, "\n"
		"LoopyWeightedSampling_addAllTargets(LoopyWeightedSampling self)\n"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_addTarget", _wrap_LoopyWeightedSampling_addTarget, METH_VARARGS, "\n"
		"LoopyWeightedSampling_addTarget(LoopyWeightedSampling self, gum::NodeId const target)\n"
		"LoopyWeightedSampling_addTarget(LoopyWeightedSampling self, std::string const & nodeName)\n"
		"\n"
		"Add a marginal target to the list of targets.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_eraseTarget", _wrap_LoopyWeightedSampling_eraseTarget, METH_VARARGS, "\n"
		"LoopyWeightedSampling_eraseTarget(LoopyWeightedSampling self, gum::NodeId const target)\n"
		"LoopyWeightedSampling_eraseTarget(LoopyWeightedSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove, if existing, the marginal target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_isTarget", _wrap_LoopyWeightedSampling_isTarget, METH_VARARGS, "\n"
		"LoopyWeightedSampling_isTarget(LoopyWeightedSampling self, gum::NodeId const variable) -> bool\n"
		"LoopyWeightedSampling_isTarget(LoopyWeightedSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : int\n"
		" a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variable is a (marginal) target\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_nbrTargets", _wrap_LoopyWeightedSampling_nbrTargets, METH_O, "\n"
		"LoopyWeightedSampling_nbrTargets(LoopyWeightedSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_H", _wrap_LoopyWeightedSampling_H, METH_VARARGS, "\n"
		"LoopyWeightedSampling_H(LoopyWeightedSampling self, gum::NodeId const X) -> double\n"
		"LoopyWeightedSampling_H(LoopyWeightedSampling self, std::string const & nodeName) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_evidenceImpact", _wrap_LoopyWeightedSampling_evidenceImpact, METH_VARARGS, "\n"
		"LoopyWeightedSampling_evidenceImpact(LoopyWeightedSampling self, gum::NodeId target, PyObject * evs) -> Potential\n"
		"LoopyWeightedSampling_evidenceImpact(LoopyWeightedSampling self, std::string const & target, Vector_string evs) -> Potential\n"
		"\n"
		"Create a pyAgrum.Potential for P(target|evs) (for all instanciation of target and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : set\n"
		"  a set of targets ids or names.\n"
		"evs : set\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"if some evs are d-separated, they are not included in the Potential.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a Potential for P(targets|evs)\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_currentPosterior", _wrap_LoopyWeightedSampling_currentPosterior, METH_VARARGS, "\n"
		"LoopyWeightedSampling_currentPosterior(LoopyWeightedSampling self, gum::NodeId const id) -> Potential\n"
		"LoopyWeightedSampling_currentPosterior(LoopyWeightedSampling self, std::string const & name) -> Potential\n"
		"\n"
		"Computes and returns the current posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the current posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LoopyWeightedSampling_swigregister", LoopyWeightedSampling_swigregister, METH_VARARGS, NULL},
	 { "LoopyWeightedSampling_swiginit", LoopyWeightedSampling_swiginit, METH_VARARGS, NULL},
	 { "new_LoopyGibbsSampling", _wrap_new_LoopyGibbsSampling, METH_O, "new_LoopyGibbsSampling(IBayesNet bn) -> LoopyGibbsSampling"},
	 { "delete_LoopyGibbsSampling", _wrap_delete_LoopyGibbsSampling, METH_O, "delete_LoopyGibbsSampling(LoopyGibbsSampling self)"},
	 { "LoopyGibbsSampling__makeInference", _wrap_LoopyGibbsSampling__makeInference, METH_O, "LoopyGibbsSampling__makeInference(LoopyGibbsSampling self)"},
	 { "LoopyGibbsSampling_setVirtualLBPSize", _wrap_LoopyGibbsSampling_setVirtualLBPSize, METH_VARARGS, "\n"
		"LoopyGibbsSampling_setVirtualLBPSize(LoopyGibbsSampling self, double vlbpsize)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"vlbpsize : double\n"
		"  the size of the virtual LBP\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setEvidence", _wrap_LoopyGibbsSampling_setEvidence, METH_VARARGS, "LoopyGibbsSampling_setEvidence(LoopyGibbsSampling self, PyObject * evidces)"},
	 { "LoopyGibbsSampling_updateEvidence", _wrap_LoopyGibbsSampling_updateEvidence, METH_VARARGS, "LoopyGibbsSampling_updateEvidence(LoopyGibbsSampling self, PyObject * evidces)"},
	 { "LoopyGibbsSampling_setTargets", _wrap_LoopyGibbsSampling_setTargets, METH_VARARGS, "LoopyGibbsSampling_setTargets(LoopyGibbsSampling self, PyObject * targets)"},
	 { "LoopyGibbsSampling_hardEvidenceNodes", _wrap_LoopyGibbsSampling_hardEvidenceNodes, METH_O, "\n"
		"LoopyGibbsSampling_hardEvidenceNodes(LoopyGibbsSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_softEvidenceNodes", _wrap_LoopyGibbsSampling_softEvidenceNodes, METH_O, "\n"
		"LoopyGibbsSampling_softEvidenceNodes(LoopyGibbsSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_targets", _wrap_LoopyGibbsSampling_targets, METH_O, "\n"
		"LoopyGibbsSampling_targets(LoopyGibbsSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setVerbosity", _wrap_LoopyGibbsSampling_setVerbosity, METH_VARARGS, "\n"
		"LoopyGibbsSampling_setVerbosity(LoopyGibbsSampling self, bool v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setEpsilon", _wrap_LoopyGibbsSampling_setEpsilon, METH_VARARGS, "\n"
		"LoopyGibbsSampling_setEpsilon(LoopyGibbsSampling self, double eps)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : double\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setMinEpsilonRate", _wrap_LoopyGibbsSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"LoopyGibbsSampling_setMinEpsilonRate(LoopyGibbsSampling self, double rate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : double\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setMaxIter", _wrap_LoopyGibbsSampling_setMaxIter, METH_VARARGS, "\n"
		"LoopyGibbsSampling_setMaxIter(LoopyGibbsSampling self, gum::Size max)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setMaxTime", _wrap_LoopyGibbsSampling_setMaxTime, METH_VARARGS, "\n"
		"LoopyGibbsSampling_setMaxTime(LoopyGibbsSampling self, double timeout)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : double\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setPeriodSize", _wrap_LoopyGibbsSampling_setPeriodSize, METH_VARARGS, "\n"
		"LoopyGibbsSampling_setPeriodSize(LoopyGibbsSampling self, gum::Size p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_verbosity", _wrap_LoopyGibbsSampling_verbosity, METH_O, "\n"
		"LoopyGibbsSampling_verbosity(LoopyGibbsSampling self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_epsilon", _wrap_LoopyGibbsSampling_epsilon, METH_O, "\n"
		"LoopyGibbsSampling_epsilon(LoopyGibbsSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_minEpsilonRate", _wrap_LoopyGibbsSampling_minEpsilonRate, METH_O, "\n"
		"LoopyGibbsSampling_minEpsilonRate(LoopyGibbsSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_maxIter", _wrap_LoopyGibbsSampling_maxIter, METH_O, "\n"
		"LoopyGibbsSampling_maxIter(LoopyGibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_maxTime", _wrap_LoopyGibbsSampling_maxTime, METH_O, "\n"
		"LoopyGibbsSampling_maxTime(LoopyGibbsSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_periodSize", _wrap_LoopyGibbsSampling_periodSize, METH_O, "\n"
		"LoopyGibbsSampling_periodSize(LoopyGibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_nbrIterations", _wrap_LoopyGibbsSampling_nbrIterations, METH_O, "\n"
		"LoopyGibbsSampling_nbrIterations(LoopyGibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_currentTime", _wrap_LoopyGibbsSampling_currentTime, METH_O, "\n"
		"LoopyGibbsSampling_currentTime(LoopyGibbsSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	get the current running time in second (double)\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_messageApproximationScheme", _wrap_LoopyGibbsSampling_messageApproximationScheme, METH_O, "\n"
		"LoopyGibbsSampling_messageApproximationScheme(LoopyGibbsSampling self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_history", _wrap_LoopyGibbsSampling_history, METH_O, "\n"
		"LoopyGibbsSampling_history(LoopyGibbsSampling self) -> Vector\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_asIApproximationSchemeConfiguration", _wrap_LoopyGibbsSampling_asIApproximationSchemeConfiguration, METH_O, "\n"
		"LoopyGibbsSampling_asIApproximationSchemeConfiguration(LoopyGibbsSampling self) -> IApproximationSchemeConfiguration\n"
		"\n"
		"Returns\n"
		"-------\n"
		"asIApproximationSchemeConfiguration\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_makeInference", _wrap_LoopyGibbsSampling_makeInference, METH_O, "\n"
		"LoopyGibbsSampling_makeInference(LoopyGibbsSampling self)\n"
		"\n"
		"Perform the heavy computations needed to compute the targets' posteriors\n"
		"\n"
		"In a Junction tree propagation scheme, for instance, the heavy computations are those of the messages sent in the JT.\n"
		"This is precisely what makeInference should compute. Later, the computations of the posteriors can be done 'lightly' by multiplying and projecting those messages.\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_posterior", _wrap_LoopyGibbsSampling_posterior, METH_VARARGS, "\n"
		"LoopyGibbsSampling_posterior(LoopyGibbsSampling self, gum::NodeId const var) -> Potential\n"
		"LoopyGibbsSampling_posterior(LoopyGibbsSampling self, std::string const nodeName) -> Potential\n"
		"\n"
		"Computes and returns the posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_BN", _wrap_LoopyGibbsSampling_BN, METH_O, "\n"
		"LoopyGibbsSampling_BN(LoopyGibbsSampling self) -> IBayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_addEvidence", _wrap_LoopyGibbsSampling_addEvidence, METH_VARARGS, "\n"
		"LoopyGibbsSampling_addEvidence(LoopyGibbsSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"LoopyGibbsSampling_addEvidence(LoopyGibbsSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"LoopyGibbsSampling_addEvidence(LoopyGibbsSampling self, gum::NodeId const id, std::string const & val)\n"
		"LoopyGibbsSampling_addEvidence(LoopyGibbsSampling self, std::string const & nodeName, std::string const & val)\n"
		"LoopyGibbsSampling_addEvidence(LoopyGibbsSampling self, gum::NodeId const id, Vector vals)\n"
		"LoopyGibbsSampling_addEvidence(LoopyGibbsSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Adds a new evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node already has an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_chgEvidence", _wrap_LoopyGibbsSampling_chgEvidence, METH_VARARGS, "\n"
		"LoopyGibbsSampling_chgEvidence(LoopyGibbsSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"LoopyGibbsSampling_chgEvidence(LoopyGibbsSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"LoopyGibbsSampling_chgEvidence(LoopyGibbsSampling self, gum::NodeId const id, std::string const & val)\n"
		"LoopyGibbsSampling_chgEvidence(LoopyGibbsSampling self, std::string const & nodeName, std::string const & val)\n"
		"LoopyGibbsSampling_chgEvidence(LoopyGibbsSampling self, gum::NodeId const id, Vector vals)\n"
		"LoopyGibbsSampling_chgEvidence(LoopyGibbsSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Change the value of an already existing evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_hasEvidence", _wrap_LoopyGibbsSampling_hasEvidence, METH_VARARGS, "\n"
		"LoopyGibbsSampling_hasEvidence(LoopyGibbsSampling self, gum::NodeId const id) -> bool\n"
		"LoopyGibbsSampling_hasEvidence(LoopyGibbsSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if some node(s) (or the one in parameters) have received evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_eraseAllEvidence", _wrap_LoopyGibbsSampling_eraseAllEvidence, METH_O, "\n"
		"LoopyGibbsSampling_eraseAllEvidence(LoopyGibbsSampling self)\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_eraseEvidence", _wrap_LoopyGibbsSampling_eraseEvidence, METH_VARARGS, "\n"
		"LoopyGibbsSampling_eraseEvidence(LoopyGibbsSampling self, gum::NodeId const id)\n"
		"LoopyGibbsSampling_eraseEvidence(LoopyGibbsSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove the evidence, if any, corresponding to the node Id or name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_hasHardEvidence", _wrap_LoopyGibbsSampling_hasHardEvidence, METH_VARARGS, "\n"
		"LoopyGibbsSampling_hasHardEvidence(LoopyGibbsSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a hard evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_hasSoftEvidence", _wrap_LoopyGibbsSampling_hasSoftEvidence, METH_VARARGS, "\n"
		"LoopyGibbsSampling_hasSoftEvidence(LoopyGibbsSampling self, gum::NodeId const id) -> bool\n"
		"LoopyGibbsSampling_hasSoftEvidence(LoopyGibbsSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a soft evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_nbrEvidence", _wrap_LoopyGibbsSampling_nbrEvidence, METH_O, "\n"
		"LoopyGibbsSampling_nbrEvidence(LoopyGibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_nbrHardEvidence", _wrap_LoopyGibbsSampling_nbrHardEvidence, METH_O, "\n"
		"LoopyGibbsSampling_nbrHardEvidence(LoopyGibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of hard evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_nbrSoftEvidence", _wrap_LoopyGibbsSampling_nbrSoftEvidence, METH_O, "\n"
		"LoopyGibbsSampling_nbrSoftEvidence(LoopyGibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of soft evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_eraseAllTargets", _wrap_LoopyGibbsSampling_eraseAllTargets, METH_O, "\n"
		"LoopyGibbsSampling_eraseAllTargets(LoopyGibbsSampling self)\n"
		"\n"
		"Clear all previously defined targets (marginal and joint targets).\n"
		"\n"
		"As a result, no posterior can be computed (since we can only compute the posteriors of the marginal or joint targets that have been added by the user).\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_addAllTargets", _wrap_LoopyGibbsSampling_addAllTargets, METH_O, "\n"
		"LoopyGibbsSampling_addAllTargets(LoopyGibbsSampling self)\n"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_addTarget", _wrap_LoopyGibbsSampling_addTarget, METH_VARARGS, "\n"
		"LoopyGibbsSampling_addTarget(LoopyGibbsSampling self, gum::NodeId const target)\n"
		"LoopyGibbsSampling_addTarget(LoopyGibbsSampling self, std::string const & nodeName)\n"
		"\n"
		"Add a marginal target to the list of targets.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_eraseTarget", _wrap_LoopyGibbsSampling_eraseTarget, METH_VARARGS, "\n"
		"LoopyGibbsSampling_eraseTarget(LoopyGibbsSampling self, gum::NodeId const target)\n"
		"LoopyGibbsSampling_eraseTarget(LoopyGibbsSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove, if existing, the marginal target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_isTarget", _wrap_LoopyGibbsSampling_isTarget, METH_VARARGS, "\n"
		"LoopyGibbsSampling_isTarget(LoopyGibbsSampling self, gum::NodeId const variable) -> bool\n"
		"LoopyGibbsSampling_isTarget(LoopyGibbsSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : int\n"
		" a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variable is a (marginal) target\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_nbrTargets", _wrap_LoopyGibbsSampling_nbrTargets, METH_O, "\n"
		"LoopyGibbsSampling_nbrTargets(LoopyGibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_H", _wrap_LoopyGibbsSampling_H, METH_VARARGS, "\n"
		"LoopyGibbsSampling_H(LoopyGibbsSampling self, gum::NodeId const X) -> double\n"
		"LoopyGibbsSampling_H(LoopyGibbsSampling self, std::string const & nodeName) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_evidenceImpact", _wrap_LoopyGibbsSampling_evidenceImpact, METH_VARARGS, "\n"
		"LoopyGibbsSampling_evidenceImpact(LoopyGibbsSampling self, gum::NodeId target, PyObject * evs) -> Potential\n"
		"LoopyGibbsSampling_evidenceImpact(LoopyGibbsSampling self, std::string const & target, Vector_string evs) -> Potential\n"
		"\n"
		"Create a pyAgrum.Potential for P(target|evs) (for all instanciation of target and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : set\n"
		"  a set of targets ids or names.\n"
		"evs : set\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"if some evs are d-separated, they are not included in the Potential.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a Potential for P(targets|evs)\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_currentPosterior", _wrap_LoopyGibbsSampling_currentPosterior, METH_VARARGS, "\n"
		"LoopyGibbsSampling_currentPosterior(LoopyGibbsSampling self, gum::NodeId const id) -> Potential\n"
		"LoopyGibbsSampling_currentPosterior(LoopyGibbsSampling self, std::string const & name) -> Potential\n"
		"\n"
		"Computes and returns the current posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the current posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_nbrDrawnVar", _wrap_LoopyGibbsSampling_nbrDrawnVar, METH_O, "\n"
		"LoopyGibbsSampling_nbrDrawnVar(LoopyGibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of variable drawn at each iteration\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setNbrDrawnVar", _wrap_LoopyGibbsSampling_setNbrDrawnVar, METH_VARARGS, "\n"
		"LoopyGibbsSampling_setNbrDrawnVar(LoopyGibbsSampling self, gum::Size _nbr)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"_nbr : int\n"
		"  the number of variables to be drawn at each iteration\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_isDrawnAtRandom", _wrap_LoopyGibbsSampling_isDrawnAtRandom, METH_O, "\n"
		"LoopyGibbsSampling_isDrawnAtRandom(LoopyGibbsSampling self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variables are drawn at random\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setDrawnAtRandom", _wrap_LoopyGibbsSampling_setDrawnAtRandom, METH_VARARGS, "\n"
		"LoopyGibbsSampling_setDrawnAtRandom(LoopyGibbsSampling self, bool _atRandom)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"_atRandom : bool\n"
		"  indicates if variables should be drawn at random\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_burnIn", _wrap_LoopyGibbsSampling_burnIn, METH_O, "\n"
		"LoopyGibbsSampling_burnIn(LoopyGibbsSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  size of burn in on number of iteration\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_setBurnIn", _wrap_LoopyGibbsSampling_setBurnIn, METH_VARARGS, "\n"
		"LoopyGibbsSampling_setBurnIn(LoopyGibbsSampling self, gum::Size b)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"b : int\n"
		"  size of burn in on number of iteration\n"
		"\n"
		""},
	 { "LoopyGibbsSampling_swigregister", LoopyGibbsSampling_swigregister, METH_VARARGS, NULL},
	 { "LoopyGibbsSampling_swiginit", LoopyGibbsSampling_swiginit, METH_VARARGS, NULL},
	 { "new_LoopyMonteCarloSampling", _wrap_new_LoopyMonteCarloSampling, METH_O, "new_LoopyMonteCarloSampling(IBayesNet bn) -> LoopyMonteCarloSampling"},
	 { "delete_LoopyMonteCarloSampling", _wrap_delete_LoopyMonteCarloSampling, METH_O, "delete_LoopyMonteCarloSampling(LoopyMonteCarloSampling self)"},
	 { "LoopyMonteCarloSampling__makeInference", _wrap_LoopyMonteCarloSampling__makeInference, METH_O, "LoopyMonteCarloSampling__makeInference(LoopyMonteCarloSampling self)"},
	 { "LoopyMonteCarloSampling_setVirtualLBPSize", _wrap_LoopyMonteCarloSampling_setVirtualLBPSize, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_setVirtualLBPSize(LoopyMonteCarloSampling self, double vlbpsize)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"vlbpsize : double\n"
		"  the size of the virtual LBP\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_setEvidence", _wrap_LoopyMonteCarloSampling_setEvidence, METH_VARARGS, "LoopyMonteCarloSampling_setEvidence(LoopyMonteCarloSampling self, PyObject * evidces)"},
	 { "LoopyMonteCarloSampling_updateEvidence", _wrap_LoopyMonteCarloSampling_updateEvidence, METH_VARARGS, "LoopyMonteCarloSampling_updateEvidence(LoopyMonteCarloSampling self, PyObject * evidces)"},
	 { "LoopyMonteCarloSampling_setTargets", _wrap_LoopyMonteCarloSampling_setTargets, METH_VARARGS, "LoopyMonteCarloSampling_setTargets(LoopyMonteCarloSampling self, PyObject * targets)"},
	 { "LoopyMonteCarloSampling_hardEvidenceNodes", _wrap_LoopyMonteCarloSampling_hardEvidenceNodes, METH_O, "\n"
		"LoopyMonteCarloSampling_hardEvidenceNodes(LoopyMonteCarloSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_softEvidenceNodes", _wrap_LoopyMonteCarloSampling_softEvidenceNodes, METH_O, "\n"
		"LoopyMonteCarloSampling_softEvidenceNodes(LoopyMonteCarloSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_targets", _wrap_LoopyMonteCarloSampling_targets, METH_O, "\n"
		"LoopyMonteCarloSampling_targets(LoopyMonteCarloSampling self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_setVerbosity", _wrap_LoopyMonteCarloSampling_setVerbosity, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_setVerbosity(LoopyMonteCarloSampling self, bool v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_setEpsilon", _wrap_LoopyMonteCarloSampling_setEpsilon, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_setEpsilon(LoopyMonteCarloSampling self, double eps)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : double\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_setMinEpsilonRate", _wrap_LoopyMonteCarloSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_setMinEpsilonRate(LoopyMonteCarloSampling self, double rate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : double\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_setMaxIter", _wrap_LoopyMonteCarloSampling_setMaxIter, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_setMaxIter(LoopyMonteCarloSampling self, gum::Size max)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_setMaxTime", _wrap_LoopyMonteCarloSampling_setMaxTime, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_setMaxTime(LoopyMonteCarloSampling self, double timeout)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : double\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_setPeriodSize", _wrap_LoopyMonteCarloSampling_setPeriodSize, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_setPeriodSize(LoopyMonteCarloSampling self, gum::Size p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_verbosity", _wrap_LoopyMonteCarloSampling_verbosity, METH_O, "\n"
		"LoopyMonteCarloSampling_verbosity(LoopyMonteCarloSampling self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_epsilon", _wrap_LoopyMonteCarloSampling_epsilon, METH_O, "\n"
		"LoopyMonteCarloSampling_epsilon(LoopyMonteCarloSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_minEpsilonRate", _wrap_LoopyMonteCarloSampling_minEpsilonRate, METH_O, "\n"
		"LoopyMonteCarloSampling_minEpsilonRate(LoopyMonteCarloSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_maxIter", _wrap_LoopyMonteCarloSampling_maxIter, METH_O, "\n"
		"LoopyMonteCarloSampling_maxIter(LoopyMonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_maxTime", _wrap_LoopyMonteCarloSampling_maxTime, METH_O, "\n"
		"LoopyMonteCarloSampling_maxTime(LoopyMonteCarloSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_periodSize", _wrap_LoopyMonteCarloSampling_periodSize, METH_O, "\n"
		"LoopyMonteCarloSampling_periodSize(LoopyMonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_nbrIterations", _wrap_LoopyMonteCarloSampling_nbrIterations, METH_O, "\n"
		"LoopyMonteCarloSampling_nbrIterations(LoopyMonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_currentTime", _wrap_LoopyMonteCarloSampling_currentTime, METH_O, "\n"
		"LoopyMonteCarloSampling_currentTime(LoopyMonteCarloSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	get the current running time in second (double)\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_messageApproximationScheme", _wrap_LoopyMonteCarloSampling_messageApproximationScheme, METH_O, "\n"
		"LoopyMonteCarloSampling_messageApproximationScheme(LoopyMonteCarloSampling self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_history", _wrap_LoopyMonteCarloSampling_history, METH_O, "\n"
		"LoopyMonteCarloSampling_history(LoopyMonteCarloSampling self) -> Vector\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_asIApproximationSchemeConfiguration", _wrap_LoopyMonteCarloSampling_asIApproximationSchemeConfiguration, METH_O, "\n"
		"LoopyMonteCarloSampling_asIApproximationSchemeConfiguration(LoopyMonteCarloSampling self) -> IApproximationSchemeConfiguration\n"
		"\n"
		"Returns\n"
		"-------\n"
		"asIApproximationSchemeConfiguration\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_makeInference", _wrap_LoopyMonteCarloSampling_makeInference, METH_O, "\n"
		"LoopyMonteCarloSampling_makeInference(LoopyMonteCarloSampling self)\n"
		"\n"
		"Perform the heavy computations needed to compute the targets' posteriors\n"
		"\n"
		"In a Junction tree propagation scheme, for instance, the heavy computations are those of the messages sent in the JT.\n"
		"This is precisely what makeInference should compute. Later, the computations of the posteriors can be done 'lightly' by multiplying and projecting those messages.\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_posterior", _wrap_LoopyMonteCarloSampling_posterior, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_posterior(LoopyMonteCarloSampling self, gum::NodeId const var) -> Potential\n"
		"LoopyMonteCarloSampling_posterior(LoopyMonteCarloSampling self, std::string const nodeName) -> Potential\n"
		"\n"
		"Computes and returns the posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_BN", _wrap_LoopyMonteCarloSampling_BN, METH_O, "\n"
		"LoopyMonteCarloSampling_BN(LoopyMonteCarloSampling self) -> IBayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_addEvidence", _wrap_LoopyMonteCarloSampling_addEvidence, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_addEvidence(LoopyMonteCarloSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"LoopyMonteCarloSampling_addEvidence(LoopyMonteCarloSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"LoopyMonteCarloSampling_addEvidence(LoopyMonteCarloSampling self, gum::NodeId const id, std::string const & val)\n"
		"LoopyMonteCarloSampling_addEvidence(LoopyMonteCarloSampling self, std::string const & nodeName, std::string const & val)\n"
		"LoopyMonteCarloSampling_addEvidence(LoopyMonteCarloSampling self, gum::NodeId const id, Vector vals)\n"
		"LoopyMonteCarloSampling_addEvidence(LoopyMonteCarloSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Adds a new evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node already has an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_chgEvidence", _wrap_LoopyMonteCarloSampling_chgEvidence, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_chgEvidence(LoopyMonteCarloSampling self, gum::NodeId const id, gum::Idx const val)\n"
		"LoopyMonteCarloSampling_chgEvidence(LoopyMonteCarloSampling self, std::string const & nodeName, gum::Idx const val)\n"
		"LoopyMonteCarloSampling_chgEvidence(LoopyMonteCarloSampling self, gum::NodeId const id, std::string const & val)\n"
		"LoopyMonteCarloSampling_chgEvidence(LoopyMonteCarloSampling self, std::string const & nodeName, std::string const & val)\n"
		"LoopyMonteCarloSampling_chgEvidence(LoopyMonteCarloSampling self, gum::NodeId const id, Vector vals)\n"
		"LoopyMonteCarloSampling_chgEvidence(LoopyMonteCarloSampling self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Change the value of an already existing evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_hasEvidence", _wrap_LoopyMonteCarloSampling_hasEvidence, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_hasEvidence(LoopyMonteCarloSampling self, gum::NodeId const id) -> bool\n"
		"LoopyMonteCarloSampling_hasEvidence(LoopyMonteCarloSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if some node(s) (or the one in parameters) have received evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_eraseAllEvidence", _wrap_LoopyMonteCarloSampling_eraseAllEvidence, METH_O, "\n"
		"LoopyMonteCarloSampling_eraseAllEvidence(LoopyMonteCarloSampling self)\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_eraseEvidence", _wrap_LoopyMonteCarloSampling_eraseEvidence, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_eraseEvidence(LoopyMonteCarloSampling self, gum::NodeId const id)\n"
		"LoopyMonteCarloSampling_eraseEvidence(LoopyMonteCarloSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove the evidence, if any, corresponding to the node Id or name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_hasHardEvidence", _wrap_LoopyMonteCarloSampling_hasHardEvidence, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_hasHardEvidence(LoopyMonteCarloSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a hard evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_hasSoftEvidence", _wrap_LoopyMonteCarloSampling_hasSoftEvidence, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_hasSoftEvidence(LoopyMonteCarloSampling self, gum::NodeId const id) -> bool\n"
		"LoopyMonteCarloSampling_hasSoftEvidence(LoopyMonteCarloSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a soft evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_nbrEvidence", _wrap_LoopyMonteCarloSampling_nbrEvidence, METH_O, "\n"
		"LoopyMonteCarloSampling_nbrEvidence(LoopyMonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_nbrHardEvidence", _wrap_LoopyMonteCarloSampling_nbrHardEvidence, METH_O, "\n"
		"LoopyMonteCarloSampling_nbrHardEvidence(LoopyMonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of hard evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_nbrSoftEvidence", _wrap_LoopyMonteCarloSampling_nbrSoftEvidence, METH_O, "\n"
		"LoopyMonteCarloSampling_nbrSoftEvidence(LoopyMonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of soft evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_eraseAllTargets", _wrap_LoopyMonteCarloSampling_eraseAllTargets, METH_O, "\n"
		"LoopyMonteCarloSampling_eraseAllTargets(LoopyMonteCarloSampling self)\n"
		"\n"
		"Clear all previously defined targets (marginal and joint targets).\n"
		"\n"
		"As a result, no posterior can be computed (since we can only compute the posteriors of the marginal or joint targets that have been added by the user).\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_addAllTargets", _wrap_LoopyMonteCarloSampling_addAllTargets, METH_O, "\n"
		"LoopyMonteCarloSampling_addAllTargets(LoopyMonteCarloSampling self)\n"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_addTarget", _wrap_LoopyMonteCarloSampling_addTarget, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_addTarget(LoopyMonteCarloSampling self, gum::NodeId const target)\n"
		"LoopyMonteCarloSampling_addTarget(LoopyMonteCarloSampling self, std::string const & nodeName)\n"
		"\n"
		"Add a marginal target to the list of targets.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_eraseTarget", _wrap_LoopyMonteCarloSampling_eraseTarget, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_eraseTarget(LoopyMonteCarloSampling self, gum::NodeId const target)\n"
		"LoopyMonteCarloSampling_eraseTarget(LoopyMonteCarloSampling self, std::string const & nodeName)\n"
		"\n"
		"Remove, if existing, the marginal target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_isTarget", _wrap_LoopyMonteCarloSampling_isTarget, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_isTarget(LoopyMonteCarloSampling self, gum::NodeId const variable) -> bool\n"
		"LoopyMonteCarloSampling_isTarget(LoopyMonteCarloSampling self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : int\n"
		" a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variable is a (marginal) target\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_nbrTargets", _wrap_LoopyMonteCarloSampling_nbrTargets, METH_O, "\n"
		"LoopyMonteCarloSampling_nbrTargets(LoopyMonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_H", _wrap_LoopyMonteCarloSampling_H, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_H(LoopyMonteCarloSampling self, gum::NodeId const X) -> double\n"
		"LoopyMonteCarloSampling_H(LoopyMonteCarloSampling self, std::string const & nodeName) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_evidenceImpact", _wrap_LoopyMonteCarloSampling_evidenceImpact, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_evidenceImpact(LoopyMonteCarloSampling self, gum::NodeId target, PyObject * evs) -> Potential\n"
		"LoopyMonteCarloSampling_evidenceImpact(LoopyMonteCarloSampling self, std::string const & target, Vector_string evs) -> Potential\n"
		"\n"
		"Create a pyAgrum.Potential for P(target|evs) (for all instanciation of target and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : set\n"
		"  a set of targets ids or names.\n"
		"evs : set\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"if some evs are d-separated, they are not included in the Potential.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a Potential for P(targets|evs)\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_currentPosterior", _wrap_LoopyMonteCarloSampling_currentPosterior, METH_VARARGS, "\n"
		"LoopyMonteCarloSampling_currentPosterior(LoopyMonteCarloSampling self, gum::NodeId const id) -> Potential\n"
		"LoopyMonteCarloSampling_currentPosterior(LoopyMonteCarloSampling self, std::string const & name) -> Potential\n"
		"\n"
		"Computes and returns the current posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the current posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LoopyMonteCarloSampling_swigregister", LoopyMonteCarloSampling_swigregister, METH_VARARGS, NULL},
	 { "LoopyMonteCarloSampling_swiginit", LoopyMonteCarloSampling_swiginit, METH_VARARGS, NULL},
	 { "new_LoopyBeliefPropagation", _wrap_new_LoopyBeliefPropagation, METH_O, "new_LoopyBeliefPropagation(IBayesNet bn) -> LoopyBeliefPropagation"},
	 { "delete_LoopyBeliefPropagation", _wrap_delete_LoopyBeliefPropagation, METH_O, "delete_LoopyBeliefPropagation(LoopyBeliefPropagation self)"},
	 { "LoopyBeliefPropagation_setEvidence", _wrap_LoopyBeliefPropagation_setEvidence, METH_VARARGS, "LoopyBeliefPropagation_setEvidence(LoopyBeliefPropagation self, PyObject * evidces)"},
	 { "LoopyBeliefPropagation_updateEvidence", _wrap_LoopyBeliefPropagation_updateEvidence, METH_VARARGS, "LoopyBeliefPropagation_updateEvidence(LoopyBeliefPropagation self, PyObject * evidces)"},
	 { "LoopyBeliefPropagation_setTargets", _wrap_LoopyBeliefPropagation_setTargets, METH_VARARGS, "LoopyBeliefPropagation_setTargets(LoopyBeliefPropagation self, PyObject * targets)"},
	 { "LoopyBeliefPropagation_hardEvidenceNodes", _wrap_LoopyBeliefPropagation_hardEvidenceNodes, METH_O, "\n"
		"LoopyBeliefPropagation_hardEvidenceNodes(LoopyBeliefPropagation self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with hard evidence\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_softEvidenceNodes", _wrap_LoopyBeliefPropagation_softEvidenceNodes, METH_O, "\n"
		"LoopyBeliefPropagation_softEvidenceNodes(LoopyBeliefPropagation self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"  the set of nodes with soft evidence\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_targets", _wrap_LoopyBeliefPropagation_targets, METH_O, "\n"
		"LoopyBeliefPropagation_targets(LoopyBeliefPropagation self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"  the list of marginal targets\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_setVerbosity", _wrap_LoopyBeliefPropagation_setVerbosity, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_setVerbosity(LoopyBeliefPropagation self, bool v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_setEpsilon", _wrap_LoopyBeliefPropagation_setEpsilon, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_setEpsilon(LoopyBeliefPropagation self, double eps)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : double\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_setMinEpsilonRate", _wrap_LoopyBeliefPropagation_setMinEpsilonRate, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_setMinEpsilonRate(LoopyBeliefPropagation self, double rate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : double\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_setMaxIter", _wrap_LoopyBeliefPropagation_setMaxIter, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_setMaxIter(LoopyBeliefPropagation self, gum::Size max)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_setMaxTime", _wrap_LoopyBeliefPropagation_setMaxTime, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_setMaxTime(LoopyBeliefPropagation self, double timeout)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : double\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_setPeriodSize", _wrap_LoopyBeliefPropagation_setPeriodSize, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_setPeriodSize(LoopyBeliefPropagation self, gum::Size p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_verbosity", _wrap_LoopyBeliefPropagation_verbosity, METH_O, "\n"
		"LoopyBeliefPropagation_verbosity(LoopyBeliefPropagation self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_epsilon", _wrap_LoopyBeliefPropagation_epsilon, METH_O, "\n"
		"LoopyBeliefPropagation_epsilon(LoopyBeliefPropagation self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_minEpsilonRate", _wrap_LoopyBeliefPropagation_minEpsilonRate, METH_O, "\n"
		"LoopyBeliefPropagation_minEpsilonRate(LoopyBeliefPropagation self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_maxIter", _wrap_LoopyBeliefPropagation_maxIter, METH_O, "\n"
		"LoopyBeliefPropagation_maxIter(LoopyBeliefPropagation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_maxTime", _wrap_LoopyBeliefPropagation_maxTime, METH_O, "\n"
		"LoopyBeliefPropagation_maxTime(LoopyBeliefPropagation self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_periodSize", _wrap_LoopyBeliefPropagation_periodSize, METH_O, "\n"
		"LoopyBeliefPropagation_periodSize(LoopyBeliefPropagation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_nbrIterations", _wrap_LoopyBeliefPropagation_nbrIterations, METH_O, "\n"
		"LoopyBeliefPropagation_nbrIterations(LoopyBeliefPropagation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_currentTime", _wrap_LoopyBeliefPropagation_currentTime, METH_O, "\n"
		"LoopyBeliefPropagation_currentTime(LoopyBeliefPropagation self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	get the current running time in second (double)\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_messageApproximationScheme", _wrap_LoopyBeliefPropagation_messageApproximationScheme, METH_O, "\n"
		"LoopyBeliefPropagation_messageApproximationScheme(LoopyBeliefPropagation self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_history", _wrap_LoopyBeliefPropagation_history, METH_O, "\n"
		"LoopyBeliefPropagation_history(LoopyBeliefPropagation self) -> Vector\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_asIApproximationSchemeConfiguration", _wrap_LoopyBeliefPropagation_asIApproximationSchemeConfiguration, METH_O, "\n"
		"LoopyBeliefPropagation_asIApproximationSchemeConfiguration(LoopyBeliefPropagation self) -> IApproximationSchemeConfiguration\n"
		"\n"
		"Returns\n"
		"-------\n"
		"asIApproximationSchemeConfiguration\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_makeInference", _wrap_LoopyBeliefPropagation_makeInference, METH_O, "\n"
		"LoopyBeliefPropagation_makeInference(LoopyBeliefPropagation self)\n"
		"\n"
		"Perform the heavy computations needed to compute the targets' posteriors\n"
		"\n"
		"In a Junction tree propagation scheme, for instance, the heavy computations are those of the messages sent in the JT.\n"
		"This is precisely what makeInference should compute. Later, the computations of the posteriors can be done 'lightly' by multiplying and projecting those messages.\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_posterior", _wrap_LoopyBeliefPropagation_posterior, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_posterior(LoopyBeliefPropagation self, gum::NodeId const var) -> Potential\n"
		"LoopyBeliefPropagation_posterior(LoopyBeliefPropagation self, std::string const nodeName) -> Potential\n"
		"\n"
		"Computes and returns the posterior of a node.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : int\n"
		"  the node Id of the node for which we need a posterior probability\n"
		"nodeName : str\n"
		"  the node name of the node for which we need a posterior probability\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a const ref to the posterior probability of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If an element of nodes is not in targets\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_BN", _wrap_LoopyBeliefPropagation_BN, METH_O, "\n"
		"LoopyBeliefPropagation_BN(LoopyBeliefPropagation self) -> IBayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.IBayesNet\n"
		"  A constant reference over the IBayesNet referenced by this class.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If no Bayes net has been assigned to the inference.\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_addEvidence", _wrap_LoopyBeliefPropagation_addEvidence, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_addEvidence(LoopyBeliefPropagation self, gum::NodeId const id, gum::Idx const val)\n"
		"LoopyBeliefPropagation_addEvidence(LoopyBeliefPropagation self, std::string const & nodeName, gum::Idx const val)\n"
		"LoopyBeliefPropagation_addEvidence(LoopyBeliefPropagation self, gum::NodeId const id, std::string const & val)\n"
		"LoopyBeliefPropagation_addEvidence(LoopyBeliefPropagation self, std::string const & nodeName, std::string const & val)\n"
		"LoopyBeliefPropagation_addEvidence(LoopyBeliefPropagation self, gum::NodeId const id, Vector vals)\n"
		"LoopyBeliefPropagation_addEvidence(LoopyBeliefPropagation self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Adds a new evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node already has an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_chgEvidence", _wrap_LoopyBeliefPropagation_chgEvidence, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_chgEvidence(LoopyBeliefPropagation self, gum::NodeId const id, gum::Idx const val)\n"
		"LoopyBeliefPropagation_chgEvidence(LoopyBeliefPropagation self, std::string const & nodeName, gum::Idx const val)\n"
		"LoopyBeliefPropagation_chgEvidence(LoopyBeliefPropagation self, gum::NodeId const id, std::string const & val)\n"
		"LoopyBeliefPropagation_chgEvidence(LoopyBeliefPropagation self, std::string const & nodeName, std::string const & val)\n"
		"LoopyBeliefPropagation_chgEvidence(LoopyBeliefPropagation self, gum::NodeId const id, Vector vals)\n"
		"LoopyBeliefPropagation_chgEvidence(LoopyBeliefPropagation self, std::string const & nodeName, Vector vals)\n"
		"\n"
		"Change the value of an already existing evidence on a node (might be soft or hard).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"val :\n"
		"  (int) a node value\n"
		"val :\n"
		"  (str) the label of the node value\n"
		"vals : list\n"
		"  a list of values\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"  If the node does not already have an evidence\n"
		"gum.InvalidArgument\n"
		"  If val is not a value for the node\n"
		"gum.InvalidArgument\n"
		"  If the size of vals is different from the domain side of the node\n"
		"gum.FatalError\n"
		"  If vals is a vector of 0s\n"
		"gum.UndefinedElement\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_hasEvidence", _wrap_LoopyBeliefPropagation_hasEvidence, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_hasEvidence(LoopyBeliefPropagation self, gum::NodeId const id) -> bool\n"
		"LoopyBeliefPropagation_hasEvidence(LoopyBeliefPropagation self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if some node(s) (or the one in parameters) have received evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_eraseAllEvidence", _wrap_LoopyBeliefPropagation_eraseAllEvidence, METH_O, "\n"
		"LoopyBeliefPropagation_eraseAllEvidence(LoopyBeliefPropagation self)\n"
		"\n"
		"Removes all the evidence entered into the network.\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_eraseEvidence", _wrap_LoopyBeliefPropagation_eraseEvidence, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_eraseEvidence(LoopyBeliefPropagation self, gum::NodeId const id)\n"
		"LoopyBeliefPropagation_eraseEvidence(LoopyBeliefPropagation self, std::string const & nodeName)\n"
		"\n"
		"Remove the evidence, if any, corresponding to the node Id or name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_hasHardEvidence", _wrap_LoopyBeliefPropagation_hasHardEvidence, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_hasHardEvidence(LoopyBeliefPropagation self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a hard evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_hasSoftEvidence", _wrap_LoopyBeliefPropagation_hasSoftEvidence, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_hasSoftEvidence(LoopyBeliefPropagation self, gum::NodeId const id) -> bool\n"
		"LoopyBeliefPropagation_hasSoftEvidence(LoopyBeliefPropagation self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if node has received a soft evidence\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_nbrEvidence", _wrap_LoopyBeliefPropagation_nbrEvidence, METH_O, "\n"
		"LoopyBeliefPropagation_nbrEvidence(LoopyBeliefPropagation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_nbrHardEvidence", _wrap_LoopyBeliefPropagation_nbrHardEvidence, METH_O, "\n"
		"LoopyBeliefPropagation_nbrHardEvidence(LoopyBeliefPropagation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of hard evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_nbrSoftEvidence", _wrap_LoopyBeliefPropagation_nbrSoftEvidence, METH_O, "\n"
		"LoopyBeliefPropagation_nbrSoftEvidence(LoopyBeliefPropagation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of soft evidence entered into the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_eraseAllTargets", _wrap_LoopyBeliefPropagation_eraseAllTargets, METH_O, "\n"
		"LoopyBeliefPropagation_eraseAllTargets(LoopyBeliefPropagation self)\n"
		"\n"
		"Clear all previously defined targets (marginal and joint targets).\n"
		"\n"
		"As a result, no posterior can be computed (since we can only compute the posteriors of the marginal or joint targets that have been added by the user).\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_addAllTargets", _wrap_LoopyBeliefPropagation_addAllTargets, METH_O, "\n"
		"LoopyBeliefPropagation_addAllTargets(LoopyBeliefPropagation self)\n"
		"\n"
		"Add all the nodes as targets.\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_addTarget", _wrap_LoopyBeliefPropagation_addTarget, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_addTarget(LoopyBeliefPropagation self, gum::NodeId const target)\n"
		"LoopyBeliefPropagation_addTarget(LoopyBeliefPropagation self, std::string const & nodeName)\n"
		"\n"
		"Add a marginal target to the list of targets.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.UndefinedElement\n"
		"  If target is not a NodeId in the Bayes net\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_eraseTarget", _wrap_LoopyBeliefPropagation_eraseTarget, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_eraseTarget(LoopyBeliefPropagation self, gum::NodeId const target)\n"
		"LoopyBeliefPropagation_eraseTarget(LoopyBeliefPropagation self, std::string const & nodeName)\n"
		"\n"
		"Remove, if existing, the marginal target.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : int\n"
		"  a node Id\n"
		"nodeName : int\n"
		"  a node name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If one of the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_isTarget", _wrap_LoopyBeliefPropagation_isTarget, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_isTarget(LoopyBeliefPropagation self, gum::NodeId const variable) -> bool\n"
		"LoopyBeliefPropagation_isTarget(LoopyBeliefPropagation self, std::string const & nodeName) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : int\n"
		" a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variable is a (marginal) target\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"  If the node does not belong to the Bayesian network\n"
		"gum.UndefinedElement\n"
		"  If node Id is not in the Bayesian network\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_nbrTargets", _wrap_LoopyBeliefPropagation_nbrTargets, METH_O, "\n"
		"LoopyBeliefPropagation_nbrTargets(LoopyBeliefPropagation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of marginal targets\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_H", _wrap_LoopyBeliefPropagation_H, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_H(LoopyBeliefPropagation self, gum::NodeId const X) -> double\n"
		"LoopyBeliefPropagation_H(LoopyBeliefPropagation self, std::string const & nodeName) -> double\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"X : int\n"
		"  a node Id\n"
		"nodeName : str\n"
		"  a node name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"  the computed Shanon's entropy of a node given the observation\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_evidenceImpact", _wrap_LoopyBeliefPropagation_evidenceImpact, METH_VARARGS, "\n"
		"LoopyBeliefPropagation_evidenceImpact(LoopyBeliefPropagation self, gum::NodeId target, PyObject * evs) -> Potential\n"
		"LoopyBeliefPropagation_evidenceImpact(LoopyBeliefPropagation self, std::string const & target, Vector_string evs) -> Potential\n"
		"\n"
		"Create a pyAgrum.Potential for P(target|evs) (for all instanciation of target and evs)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"target : set\n"
		"  a set of targets ids or names.\n"
		"evs : set\n"
		"  a set of nodes ids or names.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"if some evs are d-separated, they are not included in the Potential.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"  a Potential for P(targets|evs)\n"
		"\n"
		""},
	 { "LoopyBeliefPropagation_swigregister", LoopyBeliefPropagation_swigregister, METH_VARARGS, NULL},
	 { "LoopyBeliefPropagation_swiginit", LoopyBeliefPropagation_swiginit, METH_VARARGS, NULL},
	 { "new_ExactBNdistance", _wrap_new_ExactBNdistance, METH_VARARGS, "\n"
		"ExactBNdistance(IBayesNet P, IBayesNet Q)\n"
		"new_ExactBNdistance(gum::BNdistance< double > const & kl) -> ExactBNdistance\n"
		""},
	 { "delete_ExactBNdistance", _wrap_delete_ExactBNdistance, METH_O, "delete_ExactBNdistance(ExactBNdistance self)"},
	 { "ExactBNdistance_compute", _wrap_ExactBNdistance_compute, METH_O, "\n"
		"ExactBNdistance_compute(ExactBNdistance self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict\n"
		"	a dictionnary containing the different values after the computation.\n"
		"\n"
		""},
	 { "ExactBNdistance_swigregister", ExactBNdistance_swigregister, METH_VARARGS, NULL},
	 { "ExactBNdistance_swiginit", ExactBNdistance_swiginit, METH_VARARGS, NULL},
	 { "new_GibbsBNdistance", _wrap_new_GibbsBNdistance, METH_VARARGS, "\n"
		"GibbsBNdistance(IBayesNet P, IBayesNet Q)\n"
		"new_GibbsBNdistance(gum::BNdistance< double > const & kl) -> GibbsBNdistance\n"
		""},
	 { "delete_GibbsBNdistance", _wrap_delete_GibbsBNdistance, METH_O, "delete_GibbsBNdistance(GibbsBNdistance self)"},
	 { "GibbsBNdistance_setBurnIn", _wrap_GibbsBNdistance_setBurnIn, METH_VARARGS, "\n"
		"GibbsBNdistance_setBurnIn(GibbsBNdistance self, gum::Size b)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"b : int\n"
		"	size of burn in on number of iteration\n"
		"\n"
		""},
	 { "GibbsBNdistance_burnIn", _wrap_GibbsBNdistance_burnIn, METH_O, "\n"
		"GibbsBNdistance_burnIn(GibbsBNdistance self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	size of burn in on number of iteration\n"
		"\n"
		""},
	 { "GibbsBNdistance_compute", _wrap_GibbsBNdistance_compute, METH_O, "\n"
		"GibbsBNdistance_compute(GibbsBNdistance self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"dict\n"
		"	a dictionnary containing the different values after the computation.\n"
		"\n"
		""},
	 { "GibbsBNdistance_setVerbosity", _wrap_GibbsBNdistance_setVerbosity, METH_VARARGS, "\n"
		"GibbsBNdistance_setVerbosity(GibbsBNdistance self, bool v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "GibbsBNdistance_setEpsilon", _wrap_GibbsBNdistance_setEpsilon, METH_VARARGS, "\n"
		"GibbsBNdistance_setEpsilon(GibbsBNdistance self, double eps)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : double\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "GibbsBNdistance_setMinEpsilonRate", _wrap_GibbsBNdistance_setMinEpsilonRate, METH_VARARGS, "\n"
		"GibbsBNdistance_setMinEpsilonRate(GibbsBNdistance self, double rate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : double\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "GibbsBNdistance_setMaxIter", _wrap_GibbsBNdistance_setMaxIter, METH_VARARGS, "\n"
		"GibbsBNdistance_setMaxIter(GibbsBNdistance self, gum::Size max)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "GibbsBNdistance_setMaxTime", _wrap_GibbsBNdistance_setMaxTime, METH_VARARGS, "\n"
		"GibbsBNdistance_setMaxTime(GibbsBNdistance self, double timeout)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : double\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "GibbsBNdistance_setPeriodSize", _wrap_GibbsBNdistance_setPeriodSize, METH_VARARGS, "\n"
		"GibbsBNdistance_setPeriodSize(GibbsBNdistance self, gum::Size p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "GibbsBNdistance_verbosity", _wrap_GibbsBNdistance_verbosity, METH_O, "\n"
		"GibbsBNdistance_verbosity(GibbsBNdistance self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "GibbsBNdistance_epsilon", _wrap_GibbsBNdistance_epsilon, METH_O, "\n"
		"GibbsBNdistance_epsilon(GibbsBNdistance self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "GibbsBNdistance_minEpsilonRate", _wrap_GibbsBNdistance_minEpsilonRate, METH_O, "\n"
		"GibbsBNdistance_minEpsilonRate(GibbsBNdistance self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "GibbsBNdistance_maxIter", _wrap_GibbsBNdistance_maxIter, METH_O, "\n"
		"GibbsBNdistance_maxIter(GibbsBNdistance self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "GibbsBNdistance_maxTime", _wrap_GibbsBNdistance_maxTime, METH_O, "\n"
		"GibbsBNdistance_maxTime(GibbsBNdistance self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "GibbsBNdistance_periodSize", _wrap_GibbsBNdistance_periodSize, METH_O, "\n"
		"GibbsBNdistance_periodSize(GibbsBNdistance self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "GibbsBNdistance_nbrIterations", _wrap_GibbsBNdistance_nbrIterations, METH_O, "\n"
		"GibbsBNdistance_nbrIterations(GibbsBNdistance self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "GibbsBNdistance_currentTime", _wrap_GibbsBNdistance_currentTime, METH_O, "\n"
		"GibbsBNdistance_currentTime(GibbsBNdistance self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	get the current running time in second (double)\n"
		"\n"
		""},
	 { "GibbsBNdistance_messageApproximationScheme", _wrap_GibbsBNdistance_messageApproximationScheme, METH_O, "\n"
		"GibbsBNdistance_messageApproximationScheme(GibbsBNdistance self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "GibbsBNdistance_history", _wrap_GibbsBNdistance_history, METH_O, "\n"
		"GibbsBNdistance_history(GibbsBNdistance self) -> Vector\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "GibbsBNdistance_asIApproximationSchemeConfiguration", _wrap_GibbsBNdistance_asIApproximationSchemeConfiguration, METH_O, "\n"
		"GibbsBNdistance_asIApproximationSchemeConfiguration(GibbsBNdistance self) -> IApproximationSchemeConfiguration\n"
		"\n"
		"Returns\n"
		"-------\n"
		"asIApproximationSchemeConfiguration\n"
		"\n"
		""},
	 { "GibbsBNdistance_nbrDrawnVar", _wrap_GibbsBNdistance_nbrDrawnVar, METH_O, "\n"
		"GibbsBNdistance_nbrDrawnVar(GibbsBNdistance self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"  the number of variable drawn at each iteration\n"
		"\n"
		""},
	 { "GibbsBNdistance_setNbrDrawnVar", _wrap_GibbsBNdistance_setNbrDrawnVar, METH_VARARGS, "\n"
		"GibbsBNdistance_setNbrDrawnVar(GibbsBNdistance self, gum::Size _nbr)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"_nbr : int\n"
		"  the number of variables to be drawn at each iteration\n"
		"\n"
		""},
	 { "GibbsBNdistance_isDrawnAtRandom", _wrap_GibbsBNdistance_isDrawnAtRandom, METH_O, "\n"
		"GibbsBNdistance_isDrawnAtRandom(GibbsBNdistance self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"  True if variables are drawn at random\n"
		"\n"
		""},
	 { "GibbsBNdistance_setDrawnAtRandom", _wrap_GibbsBNdistance_setDrawnAtRandom, METH_VARARGS, "\n"
		"GibbsBNdistance_setDrawnAtRandom(GibbsBNdistance self, bool _atRandom)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"_atRandom : bool\n"
		"  indicates if variables should be drawn at random\n"
		"\n"
		""},
	 { "GibbsBNdistance_swigregister", GibbsBNdistance_swigregister, METH_VARARGS, NULL},
	 { "GibbsBNdistance_swiginit", GibbsBNdistance_swiginit, METH_VARARGS, NULL},
	 { "new_CredalNet", _wrap_new_CredalNet, METH_VARARGS, "\n"
		"CredalNet()\n"
		"CredalNet(std::string const & src_min_num, std::string const & src_max_den=\"\")\n"
		"CredalNet(BayesNet src_min_num, BayesNet src_max_den=gum::BayesNet())\n"
		""},
	 { "delete_CredalNet", _wrap_delete_CredalNet, METH_O, "delete_CredalNet(CredalNet self)"},
	 { "CredalNet_addVariable", _wrap_CredalNet_addVariable, METH_VARARGS, "\n"
		"CredalNet_addVariable(CredalNet self, std::string const & name, gum::Size const & card) -> gum::NodeId\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the name of the new variable\n"
		"card: int\n"
		"    the domainSize of the new variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the new node\n"
		"\n"
		""},
	 { "CredalNet_addArc", _wrap_CredalNet_addArc, METH_VARARGS, "\n"
		"CredalNet_addArc(CredalNet self, gum::NodeId const & tail, gum::NodeId const & head)\n"
		"\n"
		"Adds an arc between two nodes\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tail :\n"
		"	the id of the tail node\n"
		"head : int \n"
		"	the id of the head node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidDirectedCircle\n"
		"	If any (directed) cycle is created by this arc\n"
		"gum.InvalidNode\n"
		"	If head or tail does not belong to the graph nodes\n"
		"gum.DuplicateElement\n"
		"	If one of the arc already exists\n"
		"\n"
		""},
	 { "CredalNet_setCPTs", _wrap_CredalNet_setCPTs, METH_VARARGS, "\n"
		"CredalNet_setCPTs(CredalNet self, gum::NodeId const & id, std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > const & cpt)\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"(experimental function) - Parameters to be wrapped\n"
		"\n"
		"\n"
		"Set the vertices of the credal sets (all of the conditionals) of a given node\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	the NodeId of the node\n"
		"cpt	: tbw \n"
		"	the vertices of every credal set (for each instantiation of the parents)\n"
		"\n"
		"Warning\n"
		"-------\n"
		"DOES not change the BayesNet (s) associated to this credal net !\n"
		"\n"
		""},
	 { "CredalNet_setCPT", _wrap_CredalNet_setCPT, METH_VARARGS, "\n"
		"CredalNet_setCPT(CredalNet self, gum::NodeId const & id, gum::Size & entry, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const & cpt)\n"
		"CredalNet_setCPT(CredalNet self, gum::NodeId const & id, Instantiation ins, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const & cpt)\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"(experimental function) - Parameters to be wrapped\n"
		"\n"
		"\n"
		"Set the vertices of one credal set of a given node (any instantiation index)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	the Id of the node\n"
		"entry : int\n"
		"	the index of the instantiation (from 0 to K - 1) excluding the given node (only the parents are used to compute the index of the credal set)\n"
		"ins : pyAgrum.Instantiation\n"
		"	the Instantiation (only the parents matter to find the credal set index) \n"
		"cpt	: tbw\n"
		"	the vertices of every credal set (for each instantiation of the parents)\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"DOES not change the BayesNet(s) associated to this credal net !\n"
		"\n"
		""},
	 { "CredalNet_fillConstraints", _wrap_CredalNet_fillConstraints, METH_VARARGS, "\n"
		"CredalNet_fillConstraints(CredalNet self, gum::NodeId const & id, Vector lower, Vector upper)\n"
		"\n"
		"Set the interval constraints of the credal sets of a given node (all instantiations) \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int \n"
		"	The id of the node\n"
		"lower : list\n"
		"	The lower value for each probability in correct order\n"
		"upper : list\n"
		"	The upper value for each probability in correct order\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"You need to call intervalToCredal when done filling all constraints.\n"
		"\n"
		"Warning\n"
		"-------\n"
		"DOES change the BayesNet (s) associated to this credal net !\n"
		"\n"
		""},
	 { "CredalNet_fillConstraint", _wrap_CredalNet_fillConstraint, METH_VARARGS, "\n"
		"CredalNet_fillConstraint(CredalNet self, gum::NodeId const & id, gum::Idx const & entry, Vector lower, Vector upper)\n"
		"CredalNet_fillConstraint(CredalNet self, gum::NodeId const & id, Instantiation ins, Vector lower, Vector upper)\n"
		"\n"
		"Set the interval constraints of a credal set of a given node (from an instantiation index)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int \n"
		"	The id of the node\n"
		"entry : int\n"
		"	The index of the instantiation excluding the given node (only the parents are used to compute the index of the credal set)\n"
		"ins : pyAgrum.Instantiation\n"
		"	The Instantiation\n"
		"lower : list\n"
		"	The lower value for each probability in correct order\n"
		"upper : list\n"
		"	The upper value for each probability in correct order\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"You need to call intervalToCredal when done filling all constraints.\n"
		"\n"
		"Warning\n"
		"-------\n"
		"DOES change the BayesNet (s) associated to this credal net ! \n"
		"\n"
		""},
	 { "CredalNet_instantiation", _wrap_CredalNet_instantiation, METH_VARARGS, "\n"
		"CredalNet_instantiation(CredalNet self, gum::NodeId const & id) -> Instantiation\n"
		"\n"
		"Get an Instantiation from a node id, usefull to fill the constraints of the network.\n"
		"\n"
		"bnet accessors / shortcuts.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	the id of the node we want an instantiation from\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Instantiation\n"
		"    the instantiation \n"
		"\n"
		""},
	 { "CredalNet_domainSize", _wrap_CredalNet_domainSize, METH_VARARGS, "\n"
		"CredalNet_domainSize(CredalNet self, gum::NodeId const & id) -> gum::Size\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	The id of the node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    The cardinality of the node \n"
		"\n"
		""},
	 { "CredalNet_bnToCredal", _wrap_CredalNet_bnToCredal, METH_VARARGS, "\n"
		"CredalNet_bnToCredal(CredalNet self, double const beta, bool const oneNet, bool const keepZeroes=False)\n"
		"\n"
		"Perturbates the BayesNet provided as input for this CredalNet by generating intervals instead of point probabilities and then computes each vertex of each credal set.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"beta : double\n"
		"	The beta used to perturbate the network\n"
		"oneNet : bool\n"
		"	used as a flag. Set to True if one BayesNet if provided with counts, to False if two BayesNet are provided; one with probabilities (the lower net) and one with denominators over the first modalities (the upper net)\n"
		"keepZeroes : bool\n"
		"	used as a flag as whether or not - respectively True or False - we keep zeroes as zeroes. Default is False, i.e. zeroes are not kept\n"
		"\n"
		""},
	 { "CredalNet_intervalToCredalWithFiles", _wrap_CredalNet_intervalToCredalWithFiles, METH_O, "\n"
		"CredalNet_intervalToCredalWithFiles(CredalNet self)\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Deprecated : use intervalToCredal (lrsWrapper with no input / output files needed).\n"
		"\n"
		"\n"
		"Computes the vertices of each credal set according to their interval definition (uses lrs).\n"
		"\n"
		"Use this method when using a single BayesNet storing counts of events. \n"
		"\n"
		""},
	 { "CredalNet_intervalToCredal", _wrap_CredalNet_intervalToCredal, METH_O, "\n"
		"CredalNet_intervalToCredal(CredalNet self)\n"
		"\n"
		"Computes the vertices of each credal set according to their interval definition (uses lrs).\n"
		"\n"
		"Use this method when using two BayesNet, one with lower probabilities and one with upper probabilities.\n"
		"\n"
		""},
	 { "CredalNet_lagrangeNormalization", _wrap_CredalNet_lagrangeNormalization, METH_O, "\n"
		"CredalNet_lagrangeNormalization(CredalNet self)\n"
		"\n"
		"Normalize counts of a BayesNet storing counts of each events such that no probability is 0.\n"
		"\n"
		"Use this method when using a single BayesNet storing counts of events. Lagrange normalization. This call is irreversible and modify counts stored by __src_bn.\n"
		"\n"
		"Doest not performs computations of the parameters but keeps normalized counts of events only. Call idmLearning to compute the probabilities (with any parameter value). \n"
		"\n"
		""},
	 { "CredalNet_idmLearning", _wrap_CredalNet_idmLearning, METH_VARARGS, "\n"
		"CredalNet_idmLearning(CredalNet self, gum::Idx const s=0, bool const keepZeroes=False)\n"
		"\n"
		"Learns parameters from a BayesNet storing counts of events.\n"
		"\n"
		"Use this method when using a single BayesNet storing counts of events. IDM model if s > 0, standard point probability if s = 0 (default value if none precised).\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"s : int\n"
		"	the IDM parameter.\n"
		"keepZeroes : bool\n"
		"	used as a flag as whether or not - respectively True or False - we keep zeroes as zeroes. Default is False, i.e. zeroes are not kept. \n"
		"\n"
		""},
	 { "CredalNet_approximatedBinarization", _wrap_CredalNet_approximatedBinarization, METH_O, "\n"
		"CredalNet_approximatedBinarization(CredalNet self)\n"
		"\n"
		"Approximate binarization.\n"
		"\n"
		"Each bit has a lower and upper probability which is the lowest - resp. highest - over all vertices of the credal set. Enlarge the orignal credal sets and may induce huge imprecision.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Enlarge the orignal credal sets and therefor induce huge imprecision by propagation. Not recommended, use MCSampling or something else instead\n"
		"\n"
		""},
	 { "CredalNet_saveBNsMinMax", _wrap_CredalNet_saveBNsMinMax, METH_VARARGS, "\n"
		"CredalNet_saveBNsMinMax(CredalNet self, std::string const & min_path, std::string const & max_path)\n"
		"\n"
		"If this CredalNet was built over a perturbed BayesNet, one can save the intervals as two BayesNet.\n"
		"\n"
		"to call after bnToCredal(GUM_SCALAR beta) save a BN with lower probabilities and a BN with upper ones\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"min_path : str\n"
		"	the path to save the BayesNet which contains the lower probabilities of each node X.\n"
		"max_path : str\n"
		"	the path to save the BayesNet which contains the upper probabilities of each node X.\n"
		"\n"
		""},
	 { "CredalNet_computeCPTMinMax", _wrap_CredalNet_computeCPTMinMax, METH_O, "\n"
		"CredalNet_computeCPTMinMax(CredalNet self)\n"
		"\n"
		"Used with binary networks to speed-up L2U inference.\n"
		"\n"
		"Store the lower and upper probabilities of each node X over the 'True' modality.\n"
		"\n"
		""},
	 { "CredalNet_src_bn", _wrap_CredalNet_src_bn, METH_O, "\n"
		"CredalNet_src_bn(CredalNet self) -> BayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.BayesNet\n"
		"    Returns a constant reference to the original BayesNet (used as a DAG, it's CPTs does not matter). \n"
		"\n"
		""},
	 { "CredalNet_current_bn", _wrap_CredalNet_current_bn, METH_O, "\n"
		"CredalNet_current_bn(CredalNet self) -> BayesNet\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.BayesNet\n"
		"    Returs a constant reference to the actual BayesNet (used as a DAG, it's CPTs does not matter). \n"
		"\n"
		""},
	 { "CredalNet_credalNet_currentCpt", _wrap_CredalNet_credalNet_currentCpt, METH_O, "\n"
		"CredalNet_credalNet_currentCpt(CredalNet self) -> gum::NodeProperty< std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > > const &\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Experimental function - Return type to be wrapped\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tbw\n"
		"    a constant reference to the (up-to-date) CredalNet CPTs.\n"
		"\n"
		""},
	 { "CredalNet_credalNet_srcCpt", _wrap_CredalNet_credalNet_srcCpt, METH_O, "\n"
		"CredalNet_credalNet_srcCpt(CredalNet self) -> gum::NodeProperty< std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > > const &\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Experimental function - Return type to be wrapped\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tbw\n"
		"    a constant reference to the (up-to-date) CredalNet CPTs.\n"
		"\n"
		""},
	 { "CredalNet_currentNodeType", _wrap_CredalNet_currentNodeType, METH_VARARGS, "\n"
		"CredalNet_currentNodeType(CredalNet self, gum::NodeId const & id) -> gum::credal::CredalNet< double >::NodeType\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int \n"
		"	The constant reference to the choosen NodeId\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.CredalNet\n"
		"    the type of the choosen node in the (up-to-date) CredalNet __current_bn if any, __src_bn otherwise. \n"
		"\n"
		""},
	 { "CredalNet_nodeType", _wrap_CredalNet_nodeType, METH_VARARGS, "\n"
		"CredalNet_nodeType(CredalNet self, gum::NodeId const & id) -> gum::credal::CredalNet< double >::NodeType\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	the constant reference to the choosen NodeId\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.CredalNet\n"
		"	the type of the choosen node in the (up-to-date) CredalNet in __src_bn. \n"
		"\n"
		""},
	 { "CredalNet_epsilonMin", _wrap_CredalNet_epsilonMin, METH_O, "\n"
		"CredalNet_epsilonMin(CredalNet self) -> double const &\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"    a constant reference to the lowest perturbation of the BayesNet provided as input for this CredalNet. \n"
		"\n"
		""},
	 { "CredalNet_epsilonMax", _wrap_CredalNet_epsilonMax, METH_O, "\n"
		"CredalNet_epsilonMax(CredalNet self) -> double const &\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"    a constant reference to the highest perturbation of the BayesNet provided as input for this CredalNet. \n"
		"\n"
		""},
	 { "CredalNet_epsilonMean", _wrap_CredalNet_epsilonMean, METH_O, "\n"
		"CredalNet_epsilonMean(CredalNet self) -> double const &\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"    a constant reference to the average perturbation of the BayesNet provided as input for this CredalNet. \n"
		"\n"
		""},
	 { "CredalNet_isSeparatelySpecified", _wrap_CredalNet_isSeparatelySpecified, METH_O, "\n"
		"CredalNet_isSeparatelySpecified(CredalNet self) -> bool const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if this CredalNet is separately and interval specified, False otherwise. \n"
		"\n"
		""},
	 { "CredalNet_hasComputedCPTMinMax", _wrap_CredalNet_hasComputedCPTMinMax, METH_O, "\n"
		"CredalNet_hasComputedCPTMinMax(CredalNet self) -> bool const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True this CredalNet has called computeCPTMinMax() to speed-up inference with binary networks and L2U.\n"
		"\n"
		""},
	 { "CredalNet_get_CPT_min", _wrap_CredalNet_get_CPT_min, METH_O, "\n"
		"CredalNet_get_CPT_min(CredalNet self) -> std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Experimental function - Return type to be wrapped\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tbw\n"
		"	a constant reference to the lower probabilities of each node X over the 'True' modality\n"
		"\n"
		""},
	 { "CredalNet_get_CPT_max", _wrap_CredalNet_get_CPT_max, METH_O, "\n"
		"CredalNet_get_CPT_max(CredalNet self) -> std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Experimental function - Return type to be wrapped\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tbw\n"
		"	a constant reference to the upper probabilities of each node X over the 'True' modality\n"
		"\n"
		""},
	 { "CredalNet___repr__", _wrap_CredalNet___repr__, METH_O, "CredalNet___repr__(CredalNet self) -> std::string"},
	 { "CredalNet___str__", _wrap_CredalNet___str__, METH_O, "CredalNet___str__(CredalNet self) -> std::string"},
	 { "CredalNet_swigregister", CredalNet_swigregister, METH_VARARGS, NULL},
	 { "CredalNet_swiginit", CredalNet_swiginit, METH_VARARGS, NULL},
	 { "new_CNMonteCarloSampling", _wrap_new_CNMonteCarloSampling, METH_O, "new_CNMonteCarloSampling(CredalNet credalNet) -> CNMonteCarloSampling"},
	 { "delete_CNMonteCarloSampling", _wrap_delete_CNMonteCarloSampling, METH_O, "delete_CNMonteCarloSampling(CNMonteCarloSampling self)"},
	 { "CNMonteCarloSampling_makeInference", _wrap_CNMonteCarloSampling_makeInference, METH_O, "\n"
		"CNMonteCarloSampling_makeInference(CNMonteCarloSampling self)\n"
		"\n"
		"Starts the inference.\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_insertEvidenceFile", _wrap_CNMonteCarloSampling_insertEvidenceFile, METH_VARARGS, "\n"
		"CNMonteCarloSampling_insertEvidenceFile(CNMonteCarloSampling self, std::string const & path)\n"
		"\n"
		"Insert evidence from file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path : str\n"
		"	the path to the evidence file. \n"
		"\n"
		""},
	 { "CNMonteCarloSampling_setVerbosity", _wrap_CNMonteCarloSampling_setVerbosity, METH_VARARGS, "\n"
		"CNMonteCarloSampling_setVerbosity(CNMonteCarloSampling self, bool v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_setEpsilon", _wrap_CNMonteCarloSampling_setEpsilon, METH_VARARGS, "\n"
		"CNMonteCarloSampling_setEpsilon(CNMonteCarloSampling self, double eps)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : double\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_setMinEpsilonRate", _wrap_CNMonteCarloSampling_setMinEpsilonRate, METH_VARARGS, "\n"
		"CNMonteCarloSampling_setMinEpsilonRate(CNMonteCarloSampling self, double rate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : double\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_setMaxIter", _wrap_CNMonteCarloSampling_setMaxIter, METH_VARARGS, "\n"
		"CNMonteCarloSampling_setMaxIter(CNMonteCarloSampling self, gum::Size max)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_setMaxTime", _wrap_CNMonteCarloSampling_setMaxTime, METH_VARARGS, "\n"
		"CNMonteCarloSampling_setMaxTime(CNMonteCarloSampling self, double timeout)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : double\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_setPeriodSize", _wrap_CNMonteCarloSampling_setPeriodSize, METH_VARARGS, "\n"
		"CNMonteCarloSampling_setPeriodSize(CNMonteCarloSampling self, gum::Size p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_verbosity", _wrap_CNMonteCarloSampling_verbosity, METH_O, "\n"
		"CNMonteCarloSampling_verbosity(CNMonteCarloSampling self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_epsilon", _wrap_CNMonteCarloSampling_epsilon, METH_O, "\n"
		"CNMonteCarloSampling_epsilon(CNMonteCarloSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_minEpsilonRate", _wrap_CNMonteCarloSampling_minEpsilonRate, METH_O, "\n"
		"CNMonteCarloSampling_minEpsilonRate(CNMonteCarloSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_maxIter", _wrap_CNMonteCarloSampling_maxIter, METH_O, "\n"
		"CNMonteCarloSampling_maxIter(CNMonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_maxTime", _wrap_CNMonteCarloSampling_maxTime, METH_O, "\n"
		"CNMonteCarloSampling_maxTime(CNMonteCarloSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_periodSize", _wrap_CNMonteCarloSampling_periodSize, METH_O, "\n"
		"CNMonteCarloSampling_periodSize(CNMonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_nbrIterations", _wrap_CNMonteCarloSampling_nbrIterations, METH_O, "\n"
		"CNMonteCarloSampling_nbrIterations(CNMonteCarloSampling self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_currentTime", _wrap_CNMonteCarloSampling_currentTime, METH_O, "\n"
		"CNMonteCarloSampling_currentTime(CNMonteCarloSampling self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	get the current running time in second (double)\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_messageApproximationScheme", _wrap_CNMonteCarloSampling_messageApproximationScheme, METH_O, "\n"
		"CNMonteCarloSampling_messageApproximationScheme(CNMonteCarloSampling self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_history", _wrap_CNMonteCarloSampling_history, METH_O, "\n"
		"CNMonteCarloSampling_history(CNMonteCarloSampling self) -> Vector\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_asIApproximationSchemeConfiguration", _wrap_CNMonteCarloSampling_asIApproximationSchemeConfiguration, METH_O, "\n"
		"CNMonteCarloSampling_asIApproximationSchemeConfiguration(CNMonteCarloSampling self) -> IApproximationSchemeConfiguration\n"
		"\n"
		"Returns\n"
		"-------\n"
		"asIApproximationSchemeConfiguration\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_setRepetitiveInd", _wrap_CNMonteCarloSampling_setRepetitiveInd, METH_VARARGS, "\n"
		"CNMonteCarloSampling_setRepetitiveInd(CNMonteCarloSampling self, bool const flag)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"flag : bool\n"
		"	True if repetitive independence is to be used, false otherwise. Only usefull with dynamic networks. \n"
		"\n"
		""},
	 { "CNMonteCarloSampling_marginalMax", _wrap_CNMonteCarloSampling_marginalMax, METH_VARARGS, "\n"
		"CNMonteCarloSampling_marginalMax(CNMonteCarloSampling self, gum::NodeId const id) -> Vector\n"
		"CNMonteCarloSampling_marginalMax(CNMonteCarloSampling self, std::string const name) -> Vector\n"
		"\n"
		"Get the upper marginals of a given node id.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	the node id which upper marginals we want.\n"
		"varName : str\n"
		"	the variable name which upper marginals we want. \n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"    a constant reference to this node upper marginals.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the node does not belong to the Credal network\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_marginalMin", _wrap_CNMonteCarloSampling_marginalMin, METH_VARARGS, "\n"
		"CNMonteCarloSampling_marginalMin(CNMonteCarloSampling self, gum::NodeId const id) -> Vector\n"
		"CNMonteCarloSampling_marginalMin(CNMonteCarloSampling self, std::string const name) -> Vector\n"
		"\n"
		"Get the lower marginals of a given node id.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	the node id which lower marginals we want.\n"
		"varName : str\n"
		"	the variable name which lower marginals we want. \n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"    a constant reference to this node lower marginals.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the node does not belong to the Credal network\n"
		"\n"
		""},
	 { "CNMonteCarloSampling_insertModalsFile", _wrap_CNMonteCarloSampling_insertModalsFile, METH_VARARGS, "\n"
		"CNMonteCarloSampling_insertModalsFile(CNMonteCarloSampling self, std::string const & path)\n"
		"\n"
		"Insert variables modalities from file to compute expectations.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path : str\n"
		"	The path to the modalities file. \n"
		"\n"
		""},
	 { "CNMonteCarloSampling_dynamicExpMax", _wrap_CNMonteCarloSampling_dynamicExpMax, METH_VARARGS, "\n"
		"CNMonteCarloSampling_dynamicExpMax(CNMonteCarloSampling self, std::string const & varName) -> Vector\n"
		"\n"
		"Get the upper dynamic expectation of a given variable prefix.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varName : str\n"
		"	the variable name prefix which upper expectation we want.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"    a constant reference to the variable upper expectation over all time steps. \n"
		"\n"
		""},
	 { "CNMonteCarloSampling_dynamicExpMin", _wrap_CNMonteCarloSampling_dynamicExpMin, METH_VARARGS, "\n"
		"CNMonteCarloSampling_dynamicExpMin(CNMonteCarloSampling self, std::string const & varName) -> Vector\n"
		"\n"
		"Get the lower dynamic expectation of a given variable prefix.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varName : str\n"
		"	the variable name prefix which lower expectation we want.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"    a constant reference to the variable lower expectation over all time steps. \n"
		"\n"
		""},
	 { "CNMonteCarloSampling_swigregister", CNMonteCarloSampling_swigregister, METH_VARARGS, NULL},
	 { "CNMonteCarloSampling_swiginit", CNMonteCarloSampling_swiginit, METH_VARARGS, NULL},
	 { "CNLoopyPropagation_makeInference", _wrap_CNLoopyPropagation_makeInference, METH_O, "\n"
		"CNLoopyPropagation_makeInference(CNLoopyPropagation self)\n"
		"\n"
		"Starts the inference.\n"
		"\n"
		""},
	 { "CNLoopyPropagation_inferenceType", _wrap_CNLoopyPropagation_inferenceType, METH_VARARGS, "\n"
		"CNLoopyPropagation_inferenceType(CNLoopyPropagation self, gum::credal::CNLoopyPropagation< double >::InferenceType inft)\n"
		"CNLoopyPropagation_inferenceType(CNLoopyPropagation self) -> gum::credal::CNLoopyPropagation< double >::InferenceType\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the inference type\n"
		"\n"
		""},
	 { "CNLoopyPropagation_eraseAllEvidence", _wrap_CNLoopyPropagation_eraseAllEvidence, METH_O, "\n"
		"CNLoopyPropagation_eraseAllEvidence(CNLoopyPropagation self)\n"
		"\n"
		"Erase all inference related data to perform another one.\n"
		"\n"
		"You need to insert evidence again if needed but modalities are kept. You can insert new ones by using the appropriate method which will delete the old ones.\n"
		"\n"
		""},
	 { "CNLoopyPropagation_saveInference", _wrap_CNLoopyPropagation_saveInference, METH_VARARGS, "\n"
		"CNLoopyPropagation_saveInference(CNLoopyPropagation self, std::string const & path)\n"
		"\n"
		"Saves marginals.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path : str\n"
		"	The path to the file to save marginals. \n"
		"\n"
		""},
	 { "new_CNLoopyPropagation", _wrap_new_CNLoopyPropagation, METH_O, "new_CNLoopyPropagation(CredalNet cnet) -> CNLoopyPropagation"},
	 { "delete_CNLoopyPropagation", _wrap_delete_CNLoopyPropagation, METH_O, "delete_CNLoopyPropagation(CNLoopyPropagation self)"},
	 { "CNLoopyPropagation_insertEvidenceFile", _wrap_CNLoopyPropagation_insertEvidenceFile, METH_VARARGS, "\n"
		"CNLoopyPropagation_insertEvidenceFile(CNLoopyPropagation self, std::string const & path)\n"
		"\n"
		"Insert evidence from file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path : str\n"
		"	the path to the evidence file. \n"
		"\n"
		""},
	 { "CNLoopyPropagation_setVerbosity", _wrap_CNLoopyPropagation_setVerbosity, METH_VARARGS, "\n"
		"CNLoopyPropagation_setVerbosity(CNLoopyPropagation self, bool v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "CNLoopyPropagation_setEpsilon", _wrap_CNLoopyPropagation_setEpsilon, METH_VARARGS, "\n"
		"CNLoopyPropagation_setEpsilon(CNLoopyPropagation self, double eps)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : double\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "CNLoopyPropagation_setMinEpsilonRate", _wrap_CNLoopyPropagation_setMinEpsilonRate, METH_VARARGS, "\n"
		"CNLoopyPropagation_setMinEpsilonRate(CNLoopyPropagation self, double rate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : double\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "CNLoopyPropagation_setMaxIter", _wrap_CNLoopyPropagation_setMaxIter, METH_VARARGS, "\n"
		"CNLoopyPropagation_setMaxIter(CNLoopyPropagation self, gum::Size max)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "CNLoopyPropagation_setMaxTime", _wrap_CNLoopyPropagation_setMaxTime, METH_VARARGS, "\n"
		"CNLoopyPropagation_setMaxTime(CNLoopyPropagation self, double timeout)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tiemout : double\n"
		"	stopping criterion on timeout (in seconds)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If timeout<=0.0\n"
		"\n"
		""},
	 { "CNLoopyPropagation_setPeriodSize", _wrap_CNLoopyPropagation_setPeriodSize, METH_VARARGS, "\n"
		"CNLoopyPropagation_setPeriodSize(CNLoopyPropagation self, gum::Size p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "CNLoopyPropagation_verbosity", _wrap_CNLoopyPropagation_verbosity, METH_O, "\n"
		"CNLoopyPropagation_verbosity(CNLoopyPropagation self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "CNLoopyPropagation_epsilon", _wrap_CNLoopyPropagation_epsilon, METH_O, "\n"
		"CNLoopyPropagation_epsilon(CNLoopyPropagation self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "CNLoopyPropagation_minEpsilonRate", _wrap_CNLoopyPropagation_minEpsilonRate, METH_O, "\n"
		"CNLoopyPropagation_minEpsilonRate(CNLoopyPropagation self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "CNLoopyPropagation_maxIter", _wrap_CNLoopyPropagation_maxIter, METH_O, "\n"
		"CNLoopyPropagation_maxIter(CNLoopyPropagation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "CNLoopyPropagation_maxTime", _wrap_CNLoopyPropagation_maxTime, METH_O, "\n"
		"CNLoopyPropagation_maxTime(CNLoopyPropagation self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the timeout(in seconds)\n"
		"\n"
		""},
	 { "CNLoopyPropagation_periodSize", _wrap_CNLoopyPropagation_periodSize, METH_O, "\n"
		"CNLoopyPropagation_periodSize(CNLoopyPropagation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "CNLoopyPropagation_nbrIterations", _wrap_CNLoopyPropagation_nbrIterations, METH_O, "\n"
		"CNLoopyPropagation_nbrIterations(CNLoopyPropagation self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "CNLoopyPropagation_currentTime", _wrap_CNLoopyPropagation_currentTime, METH_O, "\n"
		"CNLoopyPropagation_currentTime(CNLoopyPropagation self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	get the current running time in second (double)\n"
		"\n"
		""},
	 { "CNLoopyPropagation_messageApproximationScheme", _wrap_CNLoopyPropagation_messageApproximationScheme, METH_O, "\n"
		"CNLoopyPropagation_messageApproximationScheme(CNLoopyPropagation self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "CNLoopyPropagation_history", _wrap_CNLoopyPropagation_history, METH_O, "\n"
		"CNLoopyPropagation_history(CNLoopyPropagation self) -> Vector\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "CNLoopyPropagation_asIApproximationSchemeConfiguration", _wrap_CNLoopyPropagation_asIApproximationSchemeConfiguration, METH_O, "\n"
		"CNLoopyPropagation_asIApproximationSchemeConfiguration(CNLoopyPropagation self) -> IApproximationSchemeConfiguration\n"
		"\n"
		"Returns\n"
		"-------\n"
		"asIApproximationSchemeConfiguration\n"
		"\n"
		""},
	 { "CNLoopyPropagation_setRepetitiveInd", _wrap_CNLoopyPropagation_setRepetitiveInd, METH_VARARGS, "\n"
		"CNLoopyPropagation_setRepetitiveInd(CNLoopyPropagation self, bool const flag)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"flag : bool\n"
		"	True if repetitive independence is to be used, false otherwise. Only usefull with dynamic networks. \n"
		"\n"
		""},
	 { "CNLoopyPropagation_marginalMax", _wrap_CNLoopyPropagation_marginalMax, METH_VARARGS, "\n"
		"CNLoopyPropagation_marginalMax(CNLoopyPropagation self, gum::NodeId const id) -> Vector\n"
		"CNLoopyPropagation_marginalMax(CNLoopyPropagation self, std::string const name) -> Vector\n"
		"\n"
		"Get the upper marginals of a given node id.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	the node id which upper marginals we want.\n"
		"varName : str\n"
		"	the variable name which upper marginals we want. \n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"    a constant reference to this node upper marginals.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the node does not belong to the Credal network\n"
		"\n"
		""},
	 { "CNLoopyPropagation_marginalMin", _wrap_CNLoopyPropagation_marginalMin, METH_VARARGS, "\n"
		"CNLoopyPropagation_marginalMin(CNLoopyPropagation self, gum::NodeId const id) -> Vector\n"
		"CNLoopyPropagation_marginalMin(CNLoopyPropagation self, std::string const name) -> Vector\n"
		"\n"
		"Get the lower marginals of a given node id.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	the node id which lower marginals we want.\n"
		"varName : str\n"
		"	the variable name which lower marginals we want. \n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"    a constant reference to this node lower marginals.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the node does not belong to the Credal network\n"
		"\n"
		""},
	 { "CNLoopyPropagation_insertModalsFile", _wrap_CNLoopyPropagation_insertModalsFile, METH_VARARGS, "\n"
		"CNLoopyPropagation_insertModalsFile(CNLoopyPropagation self, std::string const & path)\n"
		"\n"
		"Insert variables modalities from file to compute expectations.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path : str\n"
		"	The path to the modalities file. \n"
		"\n"
		""},
	 { "CNLoopyPropagation_dynamicExpMax", _wrap_CNLoopyPropagation_dynamicExpMax, METH_VARARGS, "\n"
		"CNLoopyPropagation_dynamicExpMax(CNLoopyPropagation self, std::string const & varName) -> Vector\n"
		"\n"
		"Get the upper dynamic expectation of a given variable prefix.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varName : str\n"
		"	the variable name prefix which upper expectation we want.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"    a constant reference to the variable upper expectation over all time steps. \n"
		"\n"
		""},
	 { "CNLoopyPropagation_dynamicExpMin", _wrap_CNLoopyPropagation_dynamicExpMin, METH_VARARGS, "\n"
		"CNLoopyPropagation_dynamicExpMin(CNLoopyPropagation self, std::string const & varName) -> Vector\n"
		"\n"
		"Get the lower dynamic expectation of a given variable prefix.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varName : str\n"
		"	the variable name prefix which lower expectation we want.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"    a constant reference to the variable lower expectation over all time steps. \n"
		"\n"
		""},
	 { "CNLoopyPropagation_swigregister", CNLoopyPropagation_swigregister, METH_VARARGS, NULL},
	 { "CNLoopyPropagation_swiginit", CNLoopyPropagation_swiginit, METH_VARARGS, NULL},
	 { "delete_InfluenceDiagram", _wrap_delete_InfluenceDiagram, METH_O, "delete_InfluenceDiagram(InfluenceDiagram self)"},
	 { "new_InfluenceDiagram", _wrap_new_InfluenceDiagram, METH_VARARGS, "\n"
		"InfluenceDiagram()\n"
		"new_InfluenceDiagram(InfluenceDiagram source) -> InfluenceDiagram\n"
		""},
	 { "InfluenceDiagram_toDot", _wrap_InfluenceDiagram_toDot, METH_O, "\n"
		"InfluenceDiagram_toDot(InfluenceDiagram self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"    a friendly display of the graph in DOT format\n"
		"\n"
		""},
	 { "InfluenceDiagram_cpt", _wrap_InfluenceDiagram_cpt, METH_VARARGS, "\n"
		"InfluenceDiagram_cpt(InfluenceDiagram self, gum::NodeId varId) -> Potential\n"
		"\n"
		"Returns the CPT of a variable.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"VarId : int\n"
		"	A variable's id in the pyAgrum.BayesNet.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"	The variable's CPT. \n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"	If no variable's id matches varId. \n"
		"\n"
		""},
	 { "InfluenceDiagram_utility", _wrap_InfluenceDiagram_utility, METH_VARARGS, "\n"
		"InfluenceDiagram_utility(InfluenceDiagram self, gum::NodeId varId) -> Potential\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varId : int \n"
		"	the tested node id.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.Potential\n"
		"	the utility table of the node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the InfluenceDiagram does not contain the variable\n"
		"\n"
		""},
	 { "InfluenceDiagram_isUtilityNode", _wrap_InfluenceDiagram_isUtilityNode, METH_VARARGS, "\n"
		"InfluenceDiagram_isUtilityNode(InfluenceDiagram self, gum::NodeId varId) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varId : int \n"
		"	the tested node id.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	true if node is an utility node\n"
		"\n"
		""},
	 { "InfluenceDiagram_isDecisionNode", _wrap_InfluenceDiagram_isDecisionNode, METH_VARARGS, "\n"
		"InfluenceDiagram_isDecisionNode(InfluenceDiagram self, gum::NodeId varId) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varId : int \n"
		"	the tested node id.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	true if node is a decision node\n"
		"\n"
		""},
	 { "InfluenceDiagram_isChanceNode", _wrap_InfluenceDiagram_isChanceNode, METH_VARARGS, "\n"
		"InfluenceDiagram_isChanceNode(InfluenceDiagram self, gum::NodeId varId) -> bool\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"varId : int \n"
		"	the tested node id.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	true if node is a chance node\n"
		"\n"
		""},
	 { "InfluenceDiagram_utilityNodeSize", _wrap_InfluenceDiagram_utilityNodeSize, METH_O, "\n"
		"InfluenceDiagram_utilityNodeSize(InfluenceDiagram self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of utility nodes\n"
		"\n"
		""},
	 { "InfluenceDiagram_chanceNodeSize", _wrap_InfluenceDiagram_chanceNodeSize, METH_O, "\n"
		"InfluenceDiagram_chanceNodeSize(InfluenceDiagram self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of chance nodes. \n"
		"\n"
		""},
	 { "InfluenceDiagram_decisionNodeSize", _wrap_InfluenceDiagram_decisionNodeSize, METH_O, "\n"
		"InfluenceDiagram_decisionNodeSize(InfluenceDiagram self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of decision nodes\n"
		"\n"
		""},
	 { "InfluenceDiagram_variable", _wrap_InfluenceDiagram_variable, METH_VARARGS, "\n"
		"InfluenceDiagram_variable(InfluenceDiagram self, gum::NodeId id) -> DiscreteVariable\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		" 	the node id\n"
		"\n"
		"Returns\n"
		"------\n"
		"pyAgrum.DiscreteVariable\n"
		"	a constant reference over a variabe given it's node id\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"	If no variable's id matches the parameter \n"
		"\n"
		""},
	 { "InfluenceDiagram_nodeId", _wrap_InfluenceDiagram_nodeId, METH_VARARGS, "\n"
		"InfluenceDiagram_nodeId(InfluenceDiagram self, DiscreteVariable var) -> gum::NodeId\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var : pyAgrum.DiscreteVariable\n"
		"	a variable\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the id of the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the InfluenceDiagram does not contain the variable\n"
		"\n"
		""},
	 { "InfluenceDiagram_idFromName", _wrap_InfluenceDiagram_idFromName, METH_VARARGS, "\n"
		"InfluenceDiagram_idFromName(InfluenceDiagram self, std::string const & name) -> gum::NodeId\n"
		"\n"
		"Returns a variable's id given its name.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the variable's name from which the id is returned.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the variable's node id. \n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.NotFound\n"
		"	If no such name exists in the graph. \n"
		"\n"
		""},
	 { "InfluenceDiagram_variableFromName", _wrap_InfluenceDiagram_variableFromName, METH_VARARGS, "\n"
		"InfluenceDiagram_variableFromName(InfluenceDiagram self, std::string const & name) -> DiscreteVariable\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	a variable's name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DiscreteVariable\n"
		"	the variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the InfluenceDiagram does not contain the variable\n"
		"\n"
		""},
	 { "InfluenceDiagram_add", _wrap_InfluenceDiagram_add, METH_VARARGS, "\n"
		"InfluenceDiagram_add(InfluenceDiagram self, DiscreteVariable variable, gum::NodeId id=0) -> gum::NodeId\n"
		"\n"
		"Add a chance variable, it's associate node and it's CPT.\n"
		"\n"
		"The id of the new variable is automatically generated.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	The variable added by copy.\n"
		"id : int\n"
		"	The chosen id. If 0, the NodeGraphPart will choose.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"give an id (not 0) should be reserved for rare and specific situations !!! \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the id of the added variable. \n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.DuplicateElement\n"
		"	If id(<>0) is already used \n"
		"\n"
		""},
	 { "InfluenceDiagram_addDecisionNode", _wrap_InfluenceDiagram_addDecisionNode, METH_VARARGS, "\n"
		"InfluenceDiagram_addDecisionNode(InfluenceDiagram self, DiscreteVariable variable, gum::NodeId id=0) -> gum::NodeId\n"
		"\n"
		"Add a decision variable.\n"
		"\n"
		"The id of the new variable is automatically generated.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	the variable added by copy.\n"
		"id : int\n"
		"	the chosen id. If 0, the NodeGraphPart will choose.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"give an id (not 0) should be reserved for rare and specific situations !!! \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the id of the added variable. \n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.DuplicateElement\n"
		"	If id(<>0) is already used \n"
		"\n"
		""},
	 { "InfluenceDiagram_addChanceNode", _wrap_InfluenceDiagram_addChanceNode, METH_VARARGS, "\n"
		"InfluenceDiagram_addChanceNode(InfluenceDiagram self, DiscreteVariable variable, gum::NodeId id=0) -> gum::NodeId\n"
		"InfluenceDiagram_addChanceNode(InfluenceDiagram self, DiscreteVariable variable, gum::MultiDimImplementation< double > * aContent, gum::NodeId id=0) -> gum::NodeId\n"
		"\n"
		"Add a chance variable, it's associate node and it's CPT.\n"
		"\n"
		"The id of the new variable is automatically generated.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	the variable added by copy.\n"
		"id : int\n"
		"	the chosen id. If 0, the NodeGraphPart will choose.\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"give an id (not 0) should be reserved for rare and specific situations !!! \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the id of the added variable. \n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.DuplicateElement\n"
		"	If id(<>0) is already used \n"
		"\n"
		""},
	 { "InfluenceDiagram_addUtilityNode", _wrap_InfluenceDiagram_addUtilityNode, METH_VARARGS, "\n"
		"InfluenceDiagram_addUtilityNode(InfluenceDiagram self, DiscreteVariable variable, gum::NodeId id=0) -> gum::NodeId\n"
		"InfluenceDiagram_addUtilityNode(InfluenceDiagram self, DiscreteVariable variable, gum::MultiDimImplementation< double > * aContent, gum::NodeId id=0) -> gum::NodeId\n"
		"\n"
		"Add a utility variable, it's associate node and it's UT. \n"
		"\n"
		"The id of the new variable is automatically generated.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"variable : pyAgrum.DiscreteVariable\n"
		"	the variable added by copy\n"
		"id : int\n"
		"	the chosen id. If 0, the NodeGraphPart will choose\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"give an id (not 0) should be reserved for rare and specific situations !!! \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"    the id of the added variable. \n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidArgument\n"
		"	If variable has more than one label\n"
		"gum.DuplicateElement\n"
		"	If id(<>0) is already used \n"
		"\n"
		""},
	 { "InfluenceDiagram_erase", _wrap_InfluenceDiagram_erase, METH_VARARGS, "\n"
		"InfluenceDiagram_erase(InfluenceDiagram self, gum::NodeId id)\n"
		"InfluenceDiagram_erase(InfluenceDiagram self, DiscreteVariable var)\n"
		"\n"
		"Erase a Variable from the network and remove the variable from all his childs.\n"
		"\n"
		"If no variable matches the id, then nothing is done.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	The id of the variable to erase.\n"
		"var : pyAgrum.DiscreteVariable\n"
		"	The reference on the variable to remove. \n"
		"\n"
		""},
	 { "InfluenceDiagram_changeVariableName", _wrap_InfluenceDiagram_changeVariableName, METH_VARARGS, "\n"
		"InfluenceDiagram_changeVariableName(InfluenceDiagram self, gum::NodeId id, std::string const & new_name)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"	the node Id\n"
		"new_name : str\n"
		"	the name of the variable \n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.DuplicateLabel\n"
		"	If this name already exists\n"
		"gum.NotFound\n"
		"	If no nodes matches id. \n"
		"\n"
		""},
	 { "InfluenceDiagram_addArc", _wrap_InfluenceDiagram_addArc, METH_VARARGS, "\n"
		"InfluenceDiagram_addArc(InfluenceDiagram self, gum::NodeId tail, gum::NodeId head)\n"
		"\n"
		"Add an arc in the ID, and update diagram's potential nodes cpt if necessary.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tail : int\n"
		"  the id of the tail node\n"
		"head : int\n"
		"  the id of the head node\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidEdge\n"
		"	If arc.tail and/or arc.head are not in the ID.\n"
		"gum.InvalidEdge\n"
		"	If tail is a utility node \n"
		"\n"
		""},
	 { "InfluenceDiagram_eraseArc", _wrap_InfluenceDiagram_eraseArc, METH_VARARGS, "\n"
		"InfluenceDiagram_eraseArc(InfluenceDiagram self, Arc arc)\n"
		"InfluenceDiagram_eraseArc(InfluenceDiagram self, gum::NodeId tail, gum::NodeId head)\n"
		"\n"
		"Removes an arc in the ID, and update diagram's potential nodes cpt if necessary.\n"
		"\n"
		"If (tail, head) doesn't exist, the nothing happens.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arc : pyAgrum.Arc\n"
		"	The arc to be removed.\n"
		"tail : int\n"
		"  the id of the tail node\n"
		"head : int\n"
		"  the id of the head node\n"
		"\n"
		""},
	 { "InfluenceDiagram_decisionOrderExists", _wrap_InfluenceDiagram_decisionOrderExists, METH_O, "\n"
		"InfluenceDiagram_decisionOrderExists(InfluenceDiagram self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if a directed path exist with all decision node\n"
		"\n"
		""},
	 { "InfluenceDiagram_getDecisionGraph", _wrap_InfluenceDiagram_getDecisionGraph, METH_O, "\n"
		"InfluenceDiagram_getDecisionGraph(InfluenceDiagram self) -> DAG\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DAG\n"
		"	the temporal Graph. \n"
		"\n"
		""},
	 { "InfluenceDiagram_getDecisionOrder", _wrap_InfluenceDiagram_getDecisionOrder, METH_O, "\n"
		"InfluenceDiagram_getDecisionOrder(InfluenceDiagram self) -> std::vector< gum::NodeId,std::allocator< gum::NodeId > > *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the sequence of decision nodes in the directed path.\n"
		"\n"
		"Raises\n"
		"------\n"
		"NotFound\n"
		"	If such a path does not exist \n"
		"\n"
		""},
	 { "InfluenceDiagram_existsPathBetween", _wrap_InfluenceDiagram_existsPathBetween, METH_VARARGS, "\n"
		"InfluenceDiagram_existsPathBetween(InfluenceDiagram self, gum::NodeId src, gum::NodeId dest) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	true if a path exists between two nodes. \n"
		"\n"
		""},
	 { "InfluenceDiagram_names", _wrap_InfluenceDiagram_names, METH_O, "\n"
		"InfluenceDiagram_names(InfluenceDiagram self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	The names of the InfluenceDiagram variables\n"
		"\n"
		""},
	 { "InfluenceDiagram_ids", _wrap_InfluenceDiagram_ids, METH_O, "\n"
		"InfluenceDiagram_ids(InfluenceDiagram self) -> PyObject *\n"
		"\n"
		".. note:: Deprecated in pyAgrum>0.13.0\n"
		"    Please use nodes() instead\n"
		"\n"
		""},
	 { "InfluenceDiagram_arcs", _wrap_InfluenceDiagram_arcs, METH_O, "\n"
		"InfluenceDiagram_arcs(InfluenceDiagram self) -> PyObject *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list:\n"
		"	the list of all the arcs in the Influence Diagram.\n"
		"\n"
		""},
	 { "InfluenceDiagram_parents", _wrap_InfluenceDiagram_parents, METH_VARARGS, "\n"
		"InfluenceDiagram_parents(InfluenceDiagram self, gum::NodeId const id) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id :\n"
		"	The id of the child node\n"
		"\n"
		"Returns\n"
		"-------\n"
		"set\n"
		"    the set of the parents ids.\n"
		"\n"
		""},
	 { "InfluenceDiagram_children", _wrap_InfluenceDiagram_children, METH_VARARGS, "\n"
		"InfluenceDiagram_children(InfluenceDiagram self, gum::NodeId const id) -> PyObject *\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id : int\n"
		"  the id of the parent\n"
		"\n"
		"Returns\n"
		"-------\n"
		"Set\n"
		"	the set of all the children\n"
		"\n"
		""},
	 { "InfluenceDiagram_loadBIFXML", _wrap_InfluenceDiagram_loadBIFXML, METH_VARARGS, "\n"
		"InfluenceDiagram_loadBIFXML(InfluenceDiagram self, std::string name, PyObject * l=(PyObject *) 0) -> bool\n"
		"\n"
		"Load a BIFXML file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the name's file\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IOError\n"
		"	If file not found\n"
		"gum.FatalError\n"
		"	If file is not valid\n"
		"\n"
		""},
	 { "InfluenceDiagram_saveBIFXML", _wrap_InfluenceDiagram_saveBIFXML, METH_VARARGS, "\n"
		"InfluenceDiagram_saveBIFXML(InfluenceDiagram self, std::string name)\n"
		"\n"
		"Save the BayesNet in a BIFXML file.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : str\n"
		"	the file's name\n"
		"\n"
		""},
	 { "InfluenceDiagram___repr__", _wrap_InfluenceDiagram___repr__, METH_O, "InfluenceDiagram___repr__(InfluenceDiagram self) -> std::string"},
	 { "InfluenceDiagram___str__", _wrap_InfluenceDiagram___str__, METH_O, "InfluenceDiagram___str__(InfluenceDiagram self) -> std::string"},
	 { "InfluenceDiagram_swigregister", InfluenceDiagram_swigregister, METH_VARARGS, NULL},
	 { "InfluenceDiagram_swiginit", InfluenceDiagram_swiginit, METH_VARARGS, NULL},
	 { "new_InfluenceDiagramInference", _wrap_new_InfluenceDiagramInference, METH_O, "new_InfluenceDiagramInference(InfluenceDiagram infDiag) -> InfluenceDiagramInference"},
	 { "delete_InfluenceDiagramInference", _wrap_delete_InfluenceDiagramInference, METH_O, "delete_InfluenceDiagramInference(InfluenceDiagramInference self)"},
	 { "InfluenceDiagramInference_makeInference", _wrap_InfluenceDiagramInference_makeInference, METH_O, "\n"
		"InfluenceDiagramInference_makeInference(InfluenceDiagramInference self)\n"
		"\n"
		"Makes the inference. \n"
		"\n"
		""},
	 { "InfluenceDiagramInference_getMEU", _wrap_InfluenceDiagramInference_getMEU, METH_O, "\n"
		"InfluenceDiagramInference_getMEU(InfluenceDiagramInference self) -> double\n"
		"\n"
		"Returns maximum expected utility obtained from inference.\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If no inference have yet been made \n"
		"\n"
		""},
	 { "InfluenceDiagramInference_getBestDecisionChoice", _wrap_InfluenceDiagramInference_getBestDecisionChoice, METH_VARARGS, "\n"
		"InfluenceDiagramInference_getBestDecisionChoice(InfluenceDiagramInference self, gum::NodeId decisionId) -> gum::Idx\n"
		"\n"
		"Returns best choice for decision variable given in parameter ( based upon MEU criteria )\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"decisionId : int\n"
		"	the id of the decision variable\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If no inference have yet been made\n"
		"gum.InvalidNode\n"
		"	If node given in parmaeter is not a decision node \n"
		"\n"
		""},
	 { "InfluenceDiagramInference_displayResult", _wrap_InfluenceDiagramInference_displayResult, METH_O, "\n"
		"InfluenceDiagramInference_displayResult(InfluenceDiagramInference self) -> std::string\n"
		"\n"
		"Displays the result of an inference.\n"
		"\n"
		""},
	 { "InfluenceDiagramInference_insertEvidence", _wrap_InfluenceDiagramInference_insertEvidence, METH_VARARGS, "\n"
		"InfluenceDiagramInference_insertEvidence(InfluenceDiagramInference self, gum::List< gum::Potential< double > const * > const & evidenceList)\n"
		"\n"
		"Insert new evidence in the graph.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"evidenceList : list\n"
		"	a list of potentials as evidences\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"If an evidence already w.r.t. a given node and a new evidence w.r.t. this node is onserted, the old evidence is removed\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If an evidence is over more than one variable\n"
		"\n"
		""},
	 { "InfluenceDiagramInference_eraseEvidence", _wrap_InfluenceDiagramInference_eraseEvidence, METH_VARARGS, "\n"
		"InfluenceDiagramInference_eraseEvidence(InfluenceDiagramInference self, Potential evidence)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"evidence : pyAgrum.Potential\n"
		"	the evidence to remove\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.IndexError\n"
		"	If the evidence does not belong to the influence diagram\n"
		"\n"
		""},
	 { "InfluenceDiagramInference_eraseAllEvidence", _wrap_InfluenceDiagramInference_eraseAllEvidence, METH_O, "\n"
		"InfluenceDiagramInference_eraseAllEvidence(InfluenceDiagramInference self)\n"
		"\n"
		"Removes all the evidence entered into the diagram.\n"
		"\n"
		""},
	 { "InfluenceDiagramInference_displayStrongJunctionTree", _wrap_InfluenceDiagramInference_displayStrongJunctionTree, METH_VARARGS, "\n"
		"InfluenceDiagramInference_displayStrongJunctionTree(InfluenceDiagramInference self, std::ostream & stream=std::cout)\n"
		"\n"
		"Displays on terminal the result of strong junction tree computation for test purpose only.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"args : TBW\n"
		"\n"
		""},
	 { "InfluenceDiagramInference_influenceDiagram", _wrap_InfluenceDiagramInference_influenceDiagram, METH_O, "\n"
		"InfluenceDiagramInference_influenceDiagram(InfluenceDiagramInference self) -> InfluenceDiagram\n"
		"\n"
		"Returns a constant reference over the InfluenceDiagram on which this class work.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.InfluenceDiagram\n"
		"	the InfluenceDiagram on which this class work\n"
		"\n"
		""},
	 { "InfluenceDiagramInference_setEvidence", _wrap_InfluenceDiagramInference_setEvidence, METH_VARARGS, "InfluenceDiagramInference_setEvidence(InfluenceDiagramInference self, PyObject * evidces)"},
	 { "InfluenceDiagramInference__setEvidence", _wrap_InfluenceDiagramInference__setEvidence, METH_VARARGS, "InfluenceDiagramInference__setEvidence(InfluenceDiagramInference self, PyObject * evidences)"},
	 { "InfluenceDiagramInference_junctionTreeToDot", _wrap_InfluenceDiagramInference_junctionTreeToDot, METH_O, "\n"
		"InfluenceDiagramInference_junctionTreeToDot(InfluenceDiagramInference self) -> std::string const\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the result of strong junction tree computation for test purpose only.\n"
		"\n"
		""},
	 { "InfluenceDiagramInference_swigregister", InfluenceDiagramInference_swigregister, METH_VARARGS, NULL},
	 { "InfluenceDiagramInference_swiginit", InfluenceDiagramInference_swiginit, METH_VARARGS, NULL},
	 { "new_BNLearner", _wrap_new_BNLearner, METH_VARARGS, "\n"
		"BNLearner(std::string const & filename, Vector_string missing_symbols={\"?\"})\n"
		"BNLearner(gum::learning::DatabaseTable< > const & db)\n"
		"BNLearner(std::string const & filename, BayesNet src, Vector_string missing_symbols={\"?\"})\n"
		"BNLearner(BNLearner arg1)\n"
		"new_BNLearner(BNLearner arg1) -> BNLearner\n"
		""},
	 { "delete_BNLearner", _wrap_delete_BNLearner, METH_O, "delete_BNLearner(BNLearner self)"},
	 { "BNLearner_learnBN", _wrap_BNLearner_learnBN, METH_O, "\n"
		"BNLearner_learnBN(BNLearner self) -> BayesNet\n"
		"\n"
		"learn a BayesNet from a file (must have read the db before)\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.BayesNet\n"
		"	the learned BayesNet\n"
		"\n"
		""},
	 { "BNLearner_learnParameters", _wrap_BNLearner_learnParameters, METH_VARARGS, "\n"
		"BNLearner_learnParameters(BNLearner self, DAG dag, bool take_into_account_score=True) -> BayesNet\n"
		"BNLearner_learnParameters(BNLearner self, bool take_into_account_score=True) -> BayesNet\n"
		"\n"
		"learns a BN (its parameters) when its structure is known.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dag : pyAgrum.DAG\n"
		"bn : pyAgrum.BayesNet\n"
		"take_into_account_score : bool\n"
		"	The dag passed in argument may have been learnt from a structure learning. In this case, if the score used to learn the structure has an implicit apriori (like K2 which has a 1-smoothing apriori), it is important to also take into account this implicit apriori for parameter learning. By default, if a score exists, we will learn parameters by taking into account the apriori specified by methods useAprioriXXX () + the implicit apriori of the score, else we just take into account the apriori specified by useAprioriXXX ()\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.BayesNet\n"
		"	the learned BayesNet\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.MissingVariableInDatabase\n"
		"	If a variable of the BN is not found in the database\n"
		"gum.UnknownLabelInDatabase\n"
		"	If a label is found in the database that do not correspond to the variable\n"
		"\n"
		""},
	 { "BNLearner_chi2", _wrap_BNLearner_chi2, METH_VARARGS, "\n"
		"BNLearner_chi2(BNLearner self, std::string const & var1, std::string const & var2, Vector_string knw={}) -> PyObject\n"
		"\n"
		"chi2 computes the chi2 statistic and pvalue for two columns, given a list of other columns.\n"
		"\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name1: str\n"
		"	the name of the first column\n"
		"\n"
		"name2 : str\n"
		"	the name of the second column\n"
		"\n"
		"knowing : [str]\n"
		"	the list of names of conditioning columns\n"
		"\n"
		"Returns\n"
		"-------\n"
		"statistic,pvalue\n"
		"	the chi2 statistic and the associated p-value as a Tuple\n"
		"\n"
		""},
	 { "BNLearner_setVerbosity", _wrap_BNLearner_setVerbosity, METH_VARARGS, "\n"
		"BNLearner_setVerbosity(BNLearner self, bool v)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"v : bool\n"
		"        verbosity\n"
		"\n"
		""},
	 { "BNLearner_setEpsilon", _wrap_BNLearner_setEpsilon, METH_VARARGS, "\n"
		"BNLearner_setEpsilon(BNLearner self, double eps)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"eps : double\n"
		"	the epsilon we want to use\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If eps<0\n"
		"\n"
		""},
	 { "BNLearner_setMinEpsilonRate", _wrap_BNLearner_setMinEpsilonRate, METH_VARARGS, "\n"
		"BNLearner_setMinEpsilonRate(BNLearner self, double rate)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"rate : double\n"
		"	the minimal epsilon rate\n"
		"\n"
		""},
	 { "BNLearner_setMaxIter", _wrap_BNLearner_setMaxIter, METH_VARARGS, "\n"
		"BNLearner_setMaxIter(BNLearner self, gum::Size max)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"max : int\n"
		"	the maximum number of iteration\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If max <= 1\n"
		"\n"
		""},
	 { "BNLearner_setMaxTime", _wrap_BNLearner_setMaxTime, METH_VARARGS, NULL},
	 { "BNLearner_setPeriodSize", _wrap_BNLearner_setPeriodSize, METH_VARARGS, "\n"
		"BNLearner_setPeriodSize(BNLearner self, gum::Size p)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"p : int\n"
		"	number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "BNLearner_verbosity", _wrap_BNLearner_verbosity, METH_O, "\n"
		"BNLearner_verbosity(BNLearner self) -> bool\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"	True if the verbosity is enabled\n"
		"\n"
		""},
	 { "BNLearner_epsilon", _wrap_BNLearner_epsilon, METH_O, "\n"
		"BNLearner_epsilon(BNLearner self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of epsilon\n"
		"\n"
		""},
	 { "BNLearner_minEpsilonRate", _wrap_BNLearner_minEpsilonRate, METH_O, "\n"
		"BNLearner_minEpsilonRate(BNLearner self) -> double\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the value of the minimal epsilon rate\n"
		"\n"
		""},
	 { "BNLearner_maxIter", _wrap_BNLearner_maxIter, METH_O, "\n"
		"BNLearner_maxIter(BNLearner self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the criterion on number of iterations\n"
		"\n"
		""},
	 { "BNLearner_maxTime", _wrap_BNLearner_maxTime, METH_VARARGS, NULL},
	 { "BNLearner_periodSize", _wrap_BNLearner_periodSize, METH_O, "\n"
		"BNLearner_periodSize(BNLearner self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of samples between 2 stopping\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OutOfLowerBound\n"
		"	If p<1\n"
		"\n"
		""},
	 { "BNLearner_nbrIterations", _wrap_BNLearner_nbrIterations, METH_O, "\n"
		"BNLearner_nbrIterations(BNLearner self) -> gum::Size\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of iterations\n"
		"\n"
		""},
	 { "BNLearner_currentTime", _wrap_BNLearner_currentTime, METH_VARARGS, NULL},
	 { "BNLearner_messageApproximationScheme", _wrap_BNLearner_messageApproximationScheme, METH_O, "\n"
		"BNLearner_messageApproximationScheme(BNLearner self) -> std::string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the approximation scheme message\n"
		"\n"
		""},
	 { "BNLearner_history", _wrap_BNLearner_history, METH_O, "\n"
		"BNLearner_history(BNLearner self) -> Vector\n"
		"\n"
		"Returns\n"
		"-------\n"
		"tuple\n"
		"	the scheme history\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.OperationNotAllowed\n"
		"	If the scheme did not performed or if verbosity is set to false\n"
		"\n"
		""},
	 { "BNLearner_asIApproximationSchemeConfiguration", _wrap_BNLearner_asIApproximationSchemeConfiguration, METH_O, "\n"
		"BNLearner_asIApproximationSchemeConfiguration(BNLearner self) -> IApproximationSchemeConfiguration\n"
		"\n"
		"Returns\n"
		"-------\n"
		"asIApproximationSchemeConfiguration\n"
		"\n"
		""},
	 { "BNLearner_learnDAG", _wrap_BNLearner_learnDAG, METH_O, "\n"
		"BNLearner_learnDAG(BNLearner self) -> DAG\n"
		"\n"
		"learn a structure from a file\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.DAG\n"
		"	the learned DAG\n"
		"\n"
		""},
	 { "BNLearner_names", _wrap_BNLearner_names, METH_O, "\n"
		"BNLearner_names(BNLearner self) -> Vector_string\n"
		"\n"
		"Returns\n"
		"-------\n"
		"List[str]\n"
		"	the names of the variables in the database\n"
		"\n"
		""},
	 { "BNLearner_idFromName", _wrap_BNLearner_idFromName, METH_VARARGS, "\n"
		"BNLearner_idFromName(BNLearner self, std::string const & var_name) -> gum::NodeId\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"var_names : str\n"
		"	a variable's name\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the column id corresponding to a variable name\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.MissingVariableInDatabase\n"
		"	If a variable of the BN is not found in the database.\n"
		"\n"
		""},
	 { "BNLearner_nameFromId", _wrap_BNLearner_nameFromId, METH_VARARGS, "\n"
		"BNLearner_nameFromId(BNLearner self, gum::NodeId id) -> std::string const &\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"id\n"
		"	a node id\n"
		"\n"
		"Returns\n"
		"-------\n"
		"str\n"
		"	the variable's name\n"
		"\n"
		""},
	 { "BNLearner_useScoreAIC", _wrap_BNLearner_useScoreAIC, METH_O, "BNLearner_useScoreAIC(BNLearner self)"},
	 { "BNLearner_useScoreBD", _wrap_BNLearner_useScoreBD, METH_O, "BNLearner_useScoreBD(BNLearner self)"},
	 { "BNLearner_useScoreBDeu", _wrap_BNLearner_useScoreBDeu, METH_O, "BNLearner_useScoreBDeu(BNLearner self)"},
	 { "BNLearner_useScoreBIC", _wrap_BNLearner_useScoreBIC, METH_O, "BNLearner_useScoreBIC(BNLearner self)"},
	 { "BNLearner_useScoreK2", _wrap_BNLearner_useScoreK2, METH_O, "BNLearner_useScoreK2(BNLearner self)"},
	 { "BNLearner_useScoreLog2Likelihood", _wrap_BNLearner_useScoreLog2Likelihood, METH_O, "BNLearner_useScoreLog2Likelihood(BNLearner self)"},
	 { "BNLearner_setDatabaseWeight", _wrap_BNLearner_setDatabaseWeight, METH_VARARGS, "\n"
		"BNLearner_setDatabaseWeight(BNLearner self, double const new_weight)\n"
		"\n"
		"Set the database weight.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"weight : double\n"
		"	the database weight\n"
		"\n"
		""},
	 { "BNLearner_useNoApriori", _wrap_BNLearner_useNoApriori, METH_O, "BNLearner_useNoApriori(BNLearner self)"},
	 { "BNLearner_useAprioriSmoothing", _wrap_BNLearner_useAprioriSmoothing, METH_VARARGS, "\n"
		"BNLearner_useAprioriSmoothing(BNLearner self, double weight=1)\n"
		"BNLearner_useAprioriSmoothing(BNLearner self)\n"
		""},
	 { "BNLearner_useAprioriDirichlet", _wrap_BNLearner_useAprioriDirichlet, METH_VARARGS, "\n"
		"BNLearner_useAprioriDirichlet(BNLearner self, std::string const & filename, double weight=1)\n"
		"BNLearner_useAprioriDirichlet(BNLearner self, std::string const & filename)\n"
		""},
	 { "BNLearner_useAprioriBDeu", _wrap_BNLearner_useAprioriBDeu, METH_VARARGS, "\n"
		"BNLearner_useAprioriBDeu(BNLearner self, double weight=1)\n"
		"BNLearner_useAprioriBDeu(BNLearner self)\n"
		"\n"
		"The BDeu apriori adds weight to all the cells of the counting tables.\n"
		"In other words, it adds weight rows in the database with equally probable\n"
		"values.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"weight : double\n"
		"	the apriori weight\n"
		"\n"
		""},
	 { "BNLearner_useGreedyHillClimbing", _wrap_BNLearner_useGreedyHillClimbing, METH_O, "BNLearner_useGreedyHillClimbing(BNLearner self)"},
	 { "BNLearner_useLocalSearchWithTabuList", _wrap_BNLearner_useLocalSearchWithTabuList, METH_VARARGS, "\n"
		"BNLearner_useLocalSearchWithTabuList(BNLearner self, gum::Size tabu_size=100, gum::Size nb_decrease=2)\n"
		"BNLearner_useLocalSearchWithTabuList(BNLearner self, gum::Size tabu_size=100)\n"
		"BNLearner_useLocalSearchWithTabuList(BNLearner self)\n"
		"\n"
		"Indicate that we wish to use a local search with tabu list\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tabu_size : int\n"
		"        The size of the tabu list\n"
		"\n"
		"nb_decrease : int\n"
		"        The max number of changes decreasing the score consecutively that we allow to apply\n"
		"\n"
		""},
	 { "BNLearner_useK2", _wrap_BNLearner_useK2, METH_VARARGS, "\n"
		"BNLearner_useK2(BNLearner self, PyObject * l)\n"
		"BNLearner_useK2(BNLearner self, gum::Sequence< gum::NodeId > const & order)\n"
		"BNLearner_useK2(BNLearner self, std::vector< gum::NodeId,std::allocator< gum::NodeId > > const & order)\n"
		"\n"
		"Indicate that we wish to use K2.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"order : list\n"
		"        a list of ids\n"
		"\n"
		""},
	 { "BNLearner_setMaxIndegree", _wrap_BNLearner_setMaxIndegree, METH_VARARGS, "BNLearner_setMaxIndegree(BNLearner self, gum::Size max_indegree)"},
	 { "BNLearner_setSliceOrder", _wrap_BNLearner_setSliceOrder, METH_VARARGS, "\n"
		"BNLearner_setSliceOrder(BNLearner self, PyObject * l)\n"
		"BNLearner_setSliceOrder(BNLearner self, gum::NodeProperty< gum::NodeId > const & slice_order)\n"
		"BNLearner_setSliceOrder(BNLearner self, std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const & slices)\n"
		"\n"
		"Set a partial order on the nodes.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"l : list\n"
		"        a list of sequences (composed of ids of rows or string)\n"
		"\n"
		""},
	 { "BNLearner_addForbiddenArc", _wrap_BNLearner_addForbiddenArc, METH_VARARGS, "\n"
		"BNLearner_addForbiddenArc(BNLearner self, Arc arc)\n"
		"BNLearner_addForbiddenArc(BNLearner self, gum::NodeId const tail, gum::NodeId const head)\n"
		"BNLearner_addForbiddenArc(BNLearner self, std::string const & tail, std::string const & head)\n"
		"\n"
		"The arc in parameters won't be added.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arc : pyAgrum.Arc\n"
		"	an arc\n"
		"head :\n"
		"	a variable's id (int)\n"
		"tail :\n"
		"	a variable's id (int)\n"
		"head :\n"
		"	a variable's name (str)\n"
		"tail :\n"
		"	a variable's name (str)\n"
		"\n"
		""},
	 { "BNLearner_eraseForbiddenArc", _wrap_BNLearner_eraseForbiddenArc, METH_VARARGS, "\n"
		"BNLearner_eraseForbiddenArc(BNLearner self, Arc arc)\n"
		"BNLearner_eraseForbiddenArc(BNLearner self, gum::NodeId const tail, gum::NodeId const head)\n"
		"BNLearner_eraseForbiddenArc(BNLearner self, std::string const & tail, std::string const & head)\n"
		"\n"
		"Allow the arc in parameter to be added if necessary.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arc : pyAgrum\n"
		"	an arc\n"
		"head :\n"
		"	a variable's id (int)\n"
		"tail :\n"
		"	a variable's id (int)\n"
		"head :\n"
		"	a variable's name (str)\n"
		"tail :\n"
		"	a variable's name (str)\n"
		"\n"
		""},
	 { "BNLearner_addMandatoryArc", _wrap_BNLearner_addMandatoryArc, METH_VARARGS, "\n"
		"BNLearner_addMandatoryArc(BNLearner self, Arc arc)\n"
		"BNLearner_addMandatoryArc(BNLearner self, gum::NodeId const tail, gum::NodeId const head)\n"
		"BNLearner_addMandatoryArc(BNLearner self, std::string const & tail, std::string const & head)\n"
		"\n"
		"Allow to add prior structural knowledge.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arc : pyAgrum.Arc\n"
		"	an arc\n"
		"head :\n"
		"	a variable's id (int)\n"
		"tail :\n"
		"	a variable's id (int)\n"
		"head :\n"
		"	a variable's name (str)\n"
		"tail :\n"
		"	a variable's name (str)\n"
		"\n"
		"Raises\n"
		"------\n"
		"gum.InvalidDirectedCycle\n"
		"	If the added arc creates a directed cycle in the DAG\n"
		"\n"
		""},
	 { "BNLearner_eraseMandatoryArc", _wrap_BNLearner_eraseMandatoryArc, METH_VARARGS, "\n"
		"BNLearner_eraseMandatoryArc(BNLearner self, Arc arc)\n"
		"BNLearner_eraseMandatoryArc(BNLearner self, gum::NodeId const tail, gum::NodeId const head)\n"
		"BNLearner_eraseMandatoryArc(BNLearner self, std::string const & tail, std::string const & head)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"arc : pyAgrum\n"
		"	an arc\n"
		"head :\n"
		"	a variable's id (int)\n"
		"tail :\n"
		"	a variable's id (int)\n"
		"head :\n"
		"	a variable's name (str)\n"
		"tail :\n"
		"	a variable's name (str)\n"
		"\n"
		""},
	 { "BNLearner_useEM", _wrap_BNLearner_useEM, METH_VARARGS, "\n"
		"BNLearner_useEM(BNLearner self, double const epsilon)\n"
		"\n"
		"Indicates if we use EM for parameter learning.\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"epsilon : double\n"
		"	if epsilon=0.0 then EM is not used\n"
		"	if epsilon>0 then EM is used and stops when the sum of the cumulative squared error on parameters is les than epsilon.\n"
		"\n"
		""},
	 { "BNLearner_hasMissingValues", _wrap_BNLearner_hasMissingValues, METH_O, "\n"
		"BNLearner_hasMissingValues(BNLearner self) -> bool\n"
		"\n"
		"Indicates whether there are missing values in the database.\n"
		"\n"
		"Returns\n"
		"-------\n"
		"bool\n"
		"    True if there are some missing values in the database.\n"
		"\n"
		""},
	 { "BNLearner_logLikelihood", _wrap_BNLearner_logLikelihood, METH_VARARGS, "\n"
		"BNLearner_logLikelihood(BNLearner self, std::vector< gum::NodeId,std::allocator< gum::NodeId > > const & vars, std::vector< gum::NodeId,std::allocator< gum::NodeId > > const & knowing={}) -> double\n"
		"BNLearner_logLikelihood(BNLearner self, std::vector< gum::NodeId,std::allocator< gum::NodeId > > const & vars) -> double\n"
		"BNLearner_logLikelihood(BNLearner self, Vector_string vars, Vector_string knowing={}) -> double\n"
		"BNLearner_logLikelihood(BNLearner self, Vector_string vars) -> double\n"
		"\n"
		"logLikelihood computes the log-likelihood for the columns in vars, given the columns in the list knowing (optional)\n"
		"\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"vars: List[str]\n"
		"	the name of the columns of interest\n"
		"\n"
		"knowing : List[str]\n"
		"	the (optional) list of names of conditioning columns\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double\n"
		"	the log-likelihood (base 2)\n"
		"\n"
		""},
	 { "BNLearner_nbRows", _wrap_BNLearner_nbRows, METH_O, "\n"
		"BNLearner_nbRows(BNLearner self) -> gum::Size\n"
		"\n"
		"Return the number of row in the database\n"
		"\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of rows in the database\n"
		"\n"
		""},
	 { "BNLearner_nbCols", _wrap_BNLearner_nbCols, METH_O, "\n"
		"BNLearner_nbCols(BNLearner self) -> gum::Size\n"
		"\n"
		"Return the nimber of columns in the database\n"
		"\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int\n"
		"	the number of columns in the database\n"
		"\n"
		""},
	 { "BNLearner_setInitialDAG", _wrap_BNLearner_setInitialDAG, METH_VARARGS, "\n"
		"BNLearner_setInitialDAG(BNLearner self, DAG g)\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dag : pyAgrum.DAG\n"
		"	an initial DAG structure\n"
		"\n"
		""},
	 { "BNLearner_use3off2", _wrap_BNLearner_use3off2, METH_O, "\n"
		"BNLearner_use3off2(BNLearner self)\n"
		"\n"
		"Indicate that we wish to use 3off2.\n"
		"\n"
		""},
	 { "BNLearner_useMIIC", _wrap_BNLearner_useMIIC, METH_O, "\n"
		"BNLearner_useMIIC(BNLearner self)\n"
		"\n"
		"Indicate that we wish to use MIIC.\n"
		"\n"
		""},
	 { "BNLearner_useNML", _wrap_BNLearner_useNML, METH_O, "\n"
		"BNLearner_useNML(BNLearner self)\n"
		"\n"
		"Indicate that we wish to use the NML correction for 3off2 or MIIC\n"
		"\n"
		""},
	 { "BNLearner_useMDL", _wrap_BNLearner_useMDL, METH_O, "\n"
		"BNLearner_useMDL(BNLearner self)\n"
		"\n"
		"Indicate that we wish to use the MDL correction for 3off2 or MIIC\n"
		"\n"
		""},
	 { "BNLearner_useNoCorr", _wrap_BNLearner_useNoCorr, METH_O, "\n"
		"BNLearner_useNoCorr(BNLearner self)\n"
		"\n"
		"Indicate that we wish to use the NoCorr correction for 3off2 or MIIC\n"
		"\n"
		""},
	 { "BNLearner_latentVariables", _wrap_BNLearner_latentVariables, METH_VARARGS, "\n"
		"BNLearner_latentVariables(BNLearner self) -> PyObject\n"
		"BNLearner_latentVariables(BNLearner self) -> std::vector< gum::Arc,std::allocator< gum::Arc > > const\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"learner must be using 3off2 or MIIC algorithm\n"
		"\n"
		"Returns\n"
		"-------\n"
		"list\n"
		"	the list of latent variables\n"
		"\n"
		""},
	 { "BNLearner_learnMixedStructure", _wrap_BNLearner_learnMixedStructure, METH_O, "\n"
		"BNLearner_learnMixedStructure(BNLearner self) -> MixedGraph\n"
		"\n"
		"Warnings\n"
		"--------\n"
		"learner must be using 3off2 or MIIC algorithm\n"
		"\n"
		"Returns\n"
		"-------\n"
		"pyAgrum.EssentialGraph\n"
		"	the learned structure as an EssentialGraph\n"
		"\n"
		""},
	 { "BNLearner_swigregister", BNLearner_swigregister, METH_VARARGS, NULL},
	 { "BNLearner_swiginit", BNLearner_swiginit, METH_VARARGS, NULL},
	 { "new_BNDatabaseGenerator", _wrap_new_BNDatabaseGenerator, METH_O, "\n"
		"new_BNDatabaseGenerator(BayesNet bn) -> BNDatabaseGenerator\n"
		"\n"
		"BNGenerator is used to easily generate databases from a gum.BayesNet.\n"
		"\n"
		"Available constructors:\n"
		"\n"
		"    ``BNDatabaseGenerator(bn) -> BNDatabaseGenerator``\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"bn: gum.BayesNet\n"
		"    the Bayesian network used to generate data.\n"
		"\n"
		""},
	 { "delete_BNDatabaseGenerator", _wrap_delete_BNDatabaseGenerator, METH_O, "delete_BNDatabaseGenerator(BNDatabaseGenerator self)"},
	 { "BNDatabaseGenerator_drawSamples", _wrap_BNDatabaseGenerator_drawSamples, METH_VARARGS, "BNDatabaseGenerator_drawSamples(BNDatabaseGenerator self, gum::Size nbSamples) -> double"},
	 { "BNDatabaseGenerator_toCSV", _wrap_BNDatabaseGenerator_toCSV, METH_VARARGS, "BNDatabaseGenerator_toCSV(BNDatabaseGenerator self, std::string const & csvFileURL, bool useLabels=True, bool append=False, std::string csvSeparator=\",\", bool checkOnAppend=False)"},
	 { "BNDatabaseGenerator_toDatabaseTable", _wrap_BNDatabaseGenerator_toDatabaseTable, METH_VARARGS, "BNDatabaseGenerator_toDatabaseTable(BNDatabaseGenerator self, bool useLabels=True) -> gum::learning::DatabaseTable< >"},
	 { "BNDatabaseGenerator_database", _wrap_BNDatabaseGenerator_database, METH_O, "BNDatabaseGenerator_database(BNDatabaseGenerator self) -> std::vector< std::vector< gum::Idx,std::allocator< gum::Idx > >,std::allocator< std::vector< gum::Idx,std::allocator< gum::Idx > > > >"},
	 { "BNDatabaseGenerator_setVarOrder", _wrap_BNDatabaseGenerator_setVarOrder, METH_VARARGS, "\n"
		"BNDatabaseGenerator_setVarOrder(BNDatabaseGenerator self, std::vector< gum::Idx,std::allocator< gum::Idx > > const & varOrder)\n"
		"BNDatabaseGenerator_setVarOrder(BNDatabaseGenerator self, Vector_string varOrder)\n"
		""},
	 { "BNDatabaseGenerator_setVarOrderFromCSV", _wrap_BNDatabaseGenerator_setVarOrderFromCSV, METH_VARARGS, "BNDatabaseGenerator_setVarOrderFromCSV(BNDatabaseGenerator self, std::string const & csvFileURL, std::string const & csvSeparator=\",\")"},
	 { "BNDatabaseGenerator_setTopologicalVarOrder", _wrap_BNDatabaseGenerator_setTopologicalVarOrder, METH_O, "BNDatabaseGenerator_setTopologicalVarOrder(BNDatabaseGenerator self)"},
	 { "BNDatabaseGenerator_setAntiTopologicalVarOrder", _wrap_BNDatabaseGenerator_setAntiTopologicalVarOrder, METH_O, "BNDatabaseGenerator_setAntiTopologicalVarOrder(BNDatabaseGenerator self)"},
	 { "BNDatabaseGenerator_setRandomVarOrder", _wrap_BNDatabaseGenerator_setRandomVarOrder, METH_O, "BNDatabaseGenerator_setRandomVarOrder(BNDatabaseGenerator self)"},
	 { "BNDatabaseGenerator_varOrder", _wrap_BNDatabaseGenerator_varOrder, METH_O, "BNDatabaseGenerator_varOrder(BNDatabaseGenerator self) -> std::vector< gum::Idx,std::allocator< gum::Idx > >"},
	 { "BNDatabaseGenerator_varOrderNames", _wrap_BNDatabaseGenerator_varOrderNames, METH_O, "BNDatabaseGenerator_varOrderNames(BNDatabaseGenerator self) -> Vector_string"},
	 { "BNDatabaseGenerator_log2likelihood", _wrap_BNDatabaseGenerator_log2likelihood, METH_O, "BNDatabaseGenerator_log2likelihood(BNDatabaseGenerator self) -> double"},
	 { "BNDatabaseGenerator_swigregister", BNDatabaseGenerator_swigregister, METH_VARARGS, NULL},
	 { "BNDatabaseGenerator_swiginit", BNDatabaseGenerator_swiginit, METH_VARARGS, NULL},
	 { "statsObj", _wrap_statsObj, METH_NOARGS, "statsObj()"},
	 { NULL, NULL, 0, NULL }
};

static PyMethodDef SwigMethods_proxydocs[] = {
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_gum__MixedGraphTo_p_gum__UndiGraph(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::UndiGraph *)  ((gum::MixedGraph *) x));
}
static void *_p_gum__CliqueGraphTo_p_gum__UndiGraph(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::UndiGraph *)  ((gum::CliqueGraph *) x));
}
static void *_p_gum__MixedGraphTo_p_gum__DiGraph(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiGraph *)  ((gum::MixedGraph *) x));
}
static void *_p_gum__DAGTo_p_gum__DiGraph(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiGraph *)  ((gum::DAG *) x));
}
static void *_p_gum__BayesNetT_double_tTo_p_gum__IBayesNetT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::IBayesNet< double > *)  ((gum::BayesNet< double > *) x));
}
static void *_p_gum__PotentialT_double_tTo_p_gum__MultiDimDecoratorT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimDecorator< double > *)  ((gum::Potential< double > *) x));
}
static void *_p_gum__MultiDimArrayT_double_tTo_p_gum__MultiDimWithOffsetT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimWithOffset< double > *)  ((gum::MultiDimArray< double > *) x));
}
static void *_p_gum__MultiDimWithOffsetT_double_tTo_p_gum__MultiDimImplementationT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimImplementation< double > *)  ((gum::MultiDimWithOffset< double > *) x));
}
static void *_p_gum__MultiDimArrayT_double_tTo_p_gum__MultiDimImplementationT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimImplementation< double > *) (gum::MultiDimWithOffset< double > *) ((gum::MultiDimArray< double > *) x));
}
static void *_p_gum__MultiDimImplementationT_double_tTo_p_gum__MultiDimContainerT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimContainer< double > *)  ((gum::MultiDimImplementation< double > *) x));
}
static void *_p_gum__MultiDimDecoratorT_double_tTo_p_gum__MultiDimContainerT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimContainer< double > *)  ((gum::MultiDimDecorator< double > *) x));
}
static void *_p_gum__MultiDimWithOffsetT_double_tTo_p_gum__MultiDimContainerT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimContainer< double > *) (gum::MultiDimImplementation< double > *) ((gum::MultiDimWithOffset< double > *) x));
}
static void *_p_gum__MultiDimArrayT_double_tTo_p_gum__MultiDimContainerT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimContainer< double > *) (gum::MultiDimImplementation< double > *)(gum::MultiDimWithOffset< double > *) ((gum::MultiDimArray< double > *) x));
}
static void *_p_gum__PotentialT_double_tTo_p_gum__MultiDimContainerT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimContainer< double > *) (gum::MultiDimDecorator< double > *) ((gum::Potential< double > *) x));
}
static void *_p_gum__ExactBNdistanceT_double_tTo_p_gum__BNdistanceT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::BNdistance< double > *)  ((gum::ExactBNdistance< double > *) x));
}
static void *_p_gum__GibbsBNdistanceT_double_tTo_p_gum__BNdistanceT_double_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::BNdistance< double > *)  ((gum::GibbsBNdistance< double > *) x));
}
static void *_p_gum__CPTNoSumTo1To_p_gum__CPTError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::CPTError *)  ((gum::CPTNoSumTo1 *) x));
}
static void *_p_gum__IBayesNetT_double_tTo_p_gum__DAGmodel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DAGmodel *)  ((gum::IBayesNet< double > *) x));
}
static void *_p_gum__BayesNetT_double_tTo_p_gum__DAGmodel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DAGmodel *) (gum::IBayesNet< double > *) ((gum::BayesNet< double > *) x));
}
static void *_p_gum__InfluenceDiagramT_double_tTo_p_gum__DAGmodel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DAGmodel *)  ((gum::InfluenceDiagram< double > *) x));
}
static void *_p_gum__MultiDimContainerT_double_tTo_p_gum__MultiDimAdressable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimAdressable *)  ((gum::MultiDimContainer< double > *) x));
}
static void *_p_gum__MultiDimImplementationT_double_tTo_p_gum__MultiDimAdressable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimAdressable *) (gum::MultiDimContainer< double > *) ((gum::MultiDimImplementation< double > *) x));
}
static void *_p_gum__MultiDimDecoratorT_double_tTo_p_gum__MultiDimAdressable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimAdressable *) (gum::MultiDimContainer< double > *) ((gum::MultiDimDecorator< double > *) x));
}
static void *_p_gum__MultiDimWithOffsetT_double_tTo_p_gum__MultiDimAdressable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimAdressable *) (gum::MultiDimContainer< double > *)(gum::MultiDimImplementation< double > *) ((gum::MultiDimWithOffset< double > *) x));
}
static void *_p_gum__MultiDimArrayT_double_tTo_p_gum__MultiDimAdressable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimAdressable *) (gum::MultiDimContainer< double > *)(gum::MultiDimImplementation< double > *)(gum::MultiDimWithOffset< double > *) ((gum::MultiDimArray< double > *) x));
}
static void *_p_gum__PotentialT_double_tTo_p_gum__MultiDimAdressable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimAdressable *) (gum::MultiDimContainer< double > *)(gum::MultiDimDecorator< double > *) ((gum::Potential< double > *) x));
}
static void *_p_gum__FormatNotFoundTo_p_gum__IOError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::IOError *)  ((gum::FormatNotFound *) x));
}
static void *_p_gum__SyntaxErrorTo_p_gum__IOError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::IOError *)  ((gum::SyntaxError *) x));
}
static void *_p_gum__ApproximationSchemeTo_p_gum__IApproximationSchemeConfiguration(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::IApproximationSchemeConfiguration *)  ((gum::ApproximationScheme *) x));
}
static void *_p_gum__GibbsBNdistanceT_double_tTo_p_gum__IApproximationSchemeConfiguration(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::IApproximationSchemeConfiguration *) (gum::ApproximationScheme *) ((gum::GibbsBNdistance< double > *) x));
}
static void *_p_gum__learning__BNLearnerT_double_tTo_p_gum__IApproximationSchemeConfiguration(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::IApproximationSchemeConfiguration *) (gum::learning::genericBNLearner *) ((gum::learning::BNLearner< double > *) x));
}
static void *_p_gum__learning__genericBNLearnerTo_p_gum__IApproximationSchemeConfiguration(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::IApproximationSchemeConfiguration *)  ((gum::learning::genericBNLearner *) x));
}
static void *_p_gum__WrongClassElementTo_p_gum__FactoryError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::FactoryError *)  ((gum::WrongClassElement *) x));
}
static void *_p_gum__FactoryInvalidStateTo_p_gum__FactoryError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::FactoryError *)  ((gum::FactoryInvalidState *) x));
}
static void *_p_gum__TypeErrorTo_p_gum__FactoryError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::FactoryError *)  ((gum::TypeError *) x));
}
static void *_p_gum__WrongTypeTo_p_gum__FactoryError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::FactoryError *)  ((gum::WrongType *) x));
}
static void *_p_gum__InvalidDirectedCycleTo_p_gum__GraphError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphError *)  ((gum::InvalidDirectedCycle *) x));
}
static void *_p_gum__NoNeighbourTo_p_gum__GraphError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphError *)  ((gum::NoNeighbour *) x));
}
static void *_p_gum__InvalidNodeTo_p_gum__GraphError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphError *)  ((gum::InvalidNode *) x));
}
static void *_p_gum__DefaultInLabelTo_p_gum__GraphError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphError *)  ((gum::DefaultInLabel *) x));
}
static void *_p_gum__NoChildTo_p_gum__GraphError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphError *)  ((gum::NoChild *) x));
}
static void *_p_gum__InvalidEdgeTo_p_gum__GraphError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphError *)  ((gum::InvalidEdge *) x));
}
static void *_p_gum__InvalidArcTo_p_gum__GraphError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphError *)  ((gum::InvalidArc *) x));
}
static void *_p_gum__NoParentTo_p_gum__GraphError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphError *)  ((gum::NoParent *) x));
}
static void *_p_gum__EmptyBSTreeTo_p_gum__GraphError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::GraphError *)  ((gum::EmptyBSTree *) x));
}
static void *_p_gum__learning__BNLearnerT_double_tTo_p_gum__learning__genericBNLearner(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::learning::genericBNLearner *)  ((gum::learning::BNLearner< double > *) x));
}
static void *_p_gum__UndiGraphTo_p_gum__NodeGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::NodeGraphPart *)  ((gum::UndiGraph *) x));
}
static void *_p_gum__DiGraphTo_p_gum__NodeGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::NodeGraphPart *)  ((gum::DiGraph *) x));
}
static void *_p_gum__MixedGraphTo_p_gum__NodeGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::NodeGraphPart *) (gum::UndiGraph *) ((gum::MixedGraph *) x));
}
static void *_p_gum__DAGTo_p_gum__NodeGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::NodeGraphPart *) (gum::DiGraph *) ((gum::DAG *) x));
}
static void *_p_gum__CliqueGraphTo_p_gum__NodeGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::NodeGraphPart *) (gum::UndiGraph *) ((gum::CliqueGraph *) x));
}
static void *_p_gum__UndiGraphTo_p_gum__EdgeGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::EdgeGraphPart *)  ((gum::UndiGraph *) x));
}
static void *_p_gum__MixedGraphTo_p_gum__EdgeGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::EdgeGraphPart *) (gum::UndiGraph *) ((gum::MixedGraph *) x));
}
static void *_p_gum__CliqueGraphTo_p_gum__EdgeGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::EdgeGraphPart *) (gum::UndiGraph *) ((gum::CliqueGraph *) x));
}
static void *_p_gum__DiGraphTo_p_gum__ArcGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ArcGraphPart *)  ((gum::DiGraph *) x));
}
static void *_p_gum__MixedGraphTo_p_gum__ArcGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ArcGraphPart *) (gum::DiGraph *) ((gum::MixedGraph *) x));
}
static void *_p_gum__DAGTo_p_gum__ArcGraphPart(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ArcGraphPart *) (gum::DiGraph *) ((gum::DAG *) x));
}
static void *_p_gum__FatalErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::FatalError *) x));
}
static void *_p_gum__WrongTypeTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::FactoryError *) ((gum::WrongType *) x));
}
static void *_p_gum__IncompatibleScoreAprioriTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::LearningError *) ((gum::IncompatibleScoreApriori *) x));
}
static void *_p_gum__PossiblyIncompatibleScoreAprioriTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::LearningError *) ((gum::PossiblyIncompatibleScoreApriori *) x));
}
static void *_p_gum__InvalidNodeTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::GraphError *) ((gum::InvalidNode *) x));
}
static void *_p_gum__GraphErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::GraphError *) x));
}
static void *_p_gum__NotFoundTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::NotFound *) x));
}
static void *_p_gum__FormatNotFoundTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::IOError *) ((gum::FormatNotFound *) x));
}
static void *_p_gum__DefaultInLabelTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::GraphError *) ((gum::DefaultInLabel *) x));
}
static void *_p_gum__InvalidDirectedCycleTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::GraphError *) ((gum::InvalidDirectedCycle *) x));
}
static void *_p_gum__ReferenceErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::ReferenceError *) x));
}
static void *_p_gum__DatabaseErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::LearningError *) ((gum::DatabaseError *) x));
}
static void *_p_gum__OperationNotAllowedTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::OperationNotAllowed *) x));
}
static void *_p_gum__CPTErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::CPTError *) x));
}
static void *_p_gum__FactoryErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::FactoryError *) x));
}
static void *_p_gum__InvalidArcTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::GraphError *) ((gum::InvalidArc *) x));
}
static void *_p_gum__OutOfUpperBoundTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ReferenceError *)(gum::OutOfBounds *) ((gum::OutOfUpperBound *) x));
}
static void *_p_gum__OutOfLowerBoundTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ReferenceError *)(gum::OutOfBounds *) ((gum::OutOfLowerBound *) x));
}
static void *_p_gum__SyntaxErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::IOError *) ((gum::SyntaxError *) x));
}
static void *_p_gum__SizeErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::SizeError *) x));
}
static void *_p_gum__TypeErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::FactoryError *) ((gum::TypeError *) x));
}
static void *_p_gum__DuplicateLabelTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ReferenceError *) ((gum::DuplicateLabel *) x));
}
static void *_p_gum__LearningErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::LearningError *) x));
}
static void *_p_gum__InvalidEdgeTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::GraphError *) ((gum::InvalidEdge *) x));
}
static void *_p_gum__InvalidArgumentsNumberTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::InvalidArgumentsNumber *) x));
}
static void *_p_gum__UndefinedIteratorValueTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::UndefinedIteratorValue *) x));
}
static void *_p_gum__IdErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::IdError *) x));
}
static void *_p_gum__InvalidArgumentTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::InvalidArgument *) x));
}
static void *_p_gum__NoNeighbourTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::GraphError *) ((gum::NoNeighbour *) x));
}
static void *_p_gum__OutOfBoundsTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ReferenceError *) ((gum::OutOfBounds *) x));
}
static void *_p_gum__EmptyBSTreeTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::GraphError *) ((gum::EmptyBSTree *) x));
}
static void *_p_gum__CPTNoSumTo1To_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::CPTError *) ((gum::CPTNoSumTo1 *) x));
}
static void *_p_gum__IncompatibleEvidenceTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::IncompatibleEvidence *) x));
}
static void *_p_gum__NoParentTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::GraphError *) ((gum::NoParent *) x));
}
static void *_p_gum__DuplicateElementTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::ReferenceError *) ((gum::DuplicateElement *) x));
}
static void *_p_gum__NullElementTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::NullElement *) x));
}
static void *_p_gum__UndefinedElementTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::UndefinedElement *) x));
}
static void *_p_gum__WrongClassElementTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::FactoryError *) ((gum::WrongClassElement *) x));
}
static void *_p_gum__NoChildTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::GraphError *) ((gum::NoChild *) x));
}
static void *_p_gum__EmptySetTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::EmptySet *) x));
}
static void *_p_gum__FactoryInvalidStateTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::FactoryError *) ((gum::FactoryInvalidState *) x));
}
static void *_p_gum__IOErrorTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::IOError *) x));
}
static void *_p_gum__UndefinedIteratorKeyTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::UndefinedIteratorKey *) x));
}
static void *_p_gum__NotImplementedYetTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *)  ((gum::NotImplementedYet *) x));
}
static void *_p_gum__MissingVariableInDatabaseTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::LearningError *) ((gum::MissingVariableInDatabase *) x));
}
static void *_p_gum__MissingValueInDatabaseTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::LearningError *) ((gum::MissingValueInDatabase *) x));
}
static void *_p_gum__UnknownLabelInDatabaseTo_p_gum__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Exception *) (gum::LearningError *) ((gum::UnknownLabelInDatabase *) x));
}
static void *_p_gum__MultiDimAdressableTo_p_gum__MultiDimInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimInterface *)  ((gum::MultiDimAdressable *) x));
}
static void *_p_gum__MultiDimContainerT_double_tTo_p_gum__MultiDimInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimInterface *) (gum::MultiDimAdressable *) ((gum::MultiDimContainer< double > *) x));
}
static void *_p_gum__MultiDimImplementationT_double_tTo_p_gum__MultiDimInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimInterface *) (gum::MultiDimAdressable *)(gum::MultiDimContainer< double > *) ((gum::MultiDimImplementation< double > *) x));
}
static void *_p_gum__MultiDimDecoratorT_double_tTo_p_gum__MultiDimInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimInterface *) (gum::MultiDimAdressable *)(gum::MultiDimContainer< double > *) ((gum::MultiDimDecorator< double > *) x));
}
static void *_p_gum__MultiDimWithOffsetT_double_tTo_p_gum__MultiDimInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimInterface *) (gum::MultiDimAdressable *)(gum::MultiDimContainer< double > *)(gum::MultiDimImplementation< double > *) ((gum::MultiDimWithOffset< double > *) x));
}
static void *_p_gum__MultiDimArrayT_double_tTo_p_gum__MultiDimInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimInterface *) (gum::MultiDimAdressable *)(gum::MultiDimContainer< double > *)(gum::MultiDimImplementation< double > *)(gum::MultiDimWithOffset< double > *) ((gum::MultiDimArray< double > *) x));
}
static void *_p_gum__PotentialT_double_tTo_p_gum__MultiDimInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimInterface *) (gum::MultiDimAdressable *)(gum::MultiDimContainer< double > *)(gum::MultiDimDecorator< double > *) ((gum::Potential< double > *) x));
}
static void *_p_gum__InstantiationTo_p_gum__MultiDimInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::MultiDimInterface *)  ((gum::Instantiation *) x));
}
static void *_p_gum__GibbsBNdistanceT_double_tTo_p_gum__ApproximationScheme(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ApproximationScheme *)  ((gum::GibbsBNdistance< double > *) x));
}
static void *_p_gum__OutOfLowerBoundTo_p_gum__OutOfBounds(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::OutOfBounds *)  ((gum::OutOfLowerBound *) x));
}
static void *_p_gum__OutOfUpperBoundTo_p_gum__OutOfBounds(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::OutOfBounds *)  ((gum::OutOfUpperBound *) x));
}
static void *_p_gum__MissingVariableInDatabaseTo_p_gum__LearningError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::LearningError *)  ((gum::MissingVariableInDatabase *) x));
}
static void *_p_gum__MissingValueInDatabaseTo_p_gum__LearningError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::LearningError *)  ((gum::MissingValueInDatabase *) x));
}
static void *_p_gum__UnknownLabelInDatabaseTo_p_gum__LearningError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::LearningError *)  ((gum::UnknownLabelInDatabase *) x));
}
static void *_p_gum__DatabaseErrorTo_p_gum__LearningError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::LearningError *)  ((gum::DatabaseError *) x));
}
static void *_p_gum__IncompatibleScoreAprioriTo_p_gum__LearningError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::LearningError *)  ((gum::IncompatibleScoreApriori *) x));
}
static void *_p_gum__PossiblyIncompatibleScoreAprioriTo_p_gum__LearningError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::LearningError *)  ((gum::PossiblyIncompatibleScoreApriori *) x));
}
static void *_p_gum__DiscretizedVariableT_double_tTo_p_gum__IDiscretizedVariable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::IDiscretizedVariable *)  ((gum::DiscretizedVariable< double > *) x));
}
static void *_p_gum__DiscreteVariableTo_p_gum__Variable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Variable *)  ((gum::DiscreteVariable *) x));
}
static void *_p_gum__LabelizedVariableTo_p_gum__Variable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Variable *) (gum::DiscreteVariable *) ((gum::LabelizedVariable *) x));
}
static void *_p_gum__RangeVariableTo_p_gum__Variable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Variable *) (gum::DiscreteVariable *) ((gum::RangeVariable *) x));
}
static void *_p_gum__IDiscretizedVariableTo_p_gum__Variable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Variable *) (gum::DiscreteVariable *) ((gum::IDiscretizedVariable *) x));
}
static void *_p_gum__DiscretizedVariableT_double_tTo_p_gum__Variable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::Variable *) (gum::DiscreteVariable *)(gum::IDiscretizedVariable *) ((gum::DiscretizedVariable< double > *) x));
}
static void *_p_gum__LabelizedVariableTo_p_gum__DiscreteVariable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiscreteVariable *)  ((gum::LabelizedVariable *) x));
}
static void *_p_gum__RangeVariableTo_p_gum__DiscreteVariable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiscreteVariable *)  ((gum::RangeVariable *) x));
}
static void *_p_gum__IDiscretizedVariableTo_p_gum__DiscreteVariable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiscreteVariable *)  ((gum::IDiscretizedVariable *) x));
}
static void *_p_gum__DiscretizedVariableT_double_tTo_p_gum__DiscreteVariable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::DiscreteVariable *) (gum::IDiscretizedVariable *) ((gum::DiscretizedVariable< double > *) x));
}
static void *_p_gum__DuplicateElementTo_p_gum__ReferenceError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ReferenceError *)  ((gum::DuplicateElement *) x));
}
static void *_p_gum__DuplicateLabelTo_p_gum__ReferenceError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ReferenceError *)  ((gum::DuplicateLabel *) x));
}
static void *_p_gum__OutOfLowerBoundTo_p_gum__ReferenceError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ReferenceError *) (gum::OutOfBounds *) ((gum::OutOfLowerBound *) x));
}
static void *_p_gum__OutOfUpperBoundTo_p_gum__ReferenceError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ReferenceError *) (gum::OutOfBounds *) ((gum::OutOfUpperBound *) x));
}
static void *_p_gum__OutOfBoundsTo_p_gum__ReferenceError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((gum::ReferenceError *)  ((gum::OutOfBounds *) x));
}
static swig_type_info _swigt__p_ArcIterator = {"_p_ArcIterator", "ArcIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BNGenerator = {"_p_BNGenerator", "BNGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EdgeIterator = {"_p_EdgeIterator", "EdgeIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IDGenerator = {"_p_IDGenerator", "IDGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_JunctionTreeGenerator = {"_p_JunctionTreeGenerator", "JunctionTreeGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NodeConstIterator = {"_p_NodeConstIterator", "NodeConstIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NodeConstIteratorSafe = {"_p_NodeConstIteratorSafe", "NodeConstIteratorSafe *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NodeIterator = {"_p_NodeIterator", "NodeIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NodeIteratorSafe = {"_p_NodeIteratorSafe", "NodeIteratorSafe *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PRMexplorer = {"_p_PRMexplorer", "PRMexplorer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PythonApproximationListener = {"_p_PythonApproximationListener", "PythonApproximationListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PythonBNListener = {"_p_PythonBNListener", "PythonBNListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PythonDatabaseGeneratorListener = {"_p_PythonDatabaseGeneratorListener", "PythonDatabaseGeneratorListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PythonLoadListener = {"_p_PythonLoadListener", "PythonLoadListener *", 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_char = {"_p_char", "char *", 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_gum__ApproximationScheme = {"_p_gum__ApproximationScheme", "gum::ApproximationScheme *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__Arc = {"_p_gum__Arc", "gum::Arc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__ArcGraphPart = {"_p_gum__ArcGraphPart", "gum::ArcGraphPart *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__BNdistanceT_double_t = {"_p_gum__BNdistanceT_double_t", "gum::BNdistance< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__BayesNetInferenceT_double_t = {"_p_gum__BayesNetInferenceT_double_t", "gum::BayesNetInference< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__BayesNetT_double_t = {"_p_gum__BayesNetT_double_t", "gum::BayesNet< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__CPTError = {"_p_gum__CPTError", "gum::CPTError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__CPTNoSumTo1 = {"_p_gum__CPTNoSumTo1", "gum::CPTNoSumTo1 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__CliqueGraph = {"_p_gum__CliqueGraph", "gum::JoinTree *|gum::JunctionTree *|gum::CliqueGraph *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__DAG = {"_p_gum__DAG", "gum::DAG *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__DAGmodel = {"_p_gum__DAGmodel", "gum::DAGmodel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__DatabaseError = {"_p_gum__DatabaseError", "gum::DatabaseError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__DefaultInLabel = {"_p_gum__DefaultInLabel", "gum::DefaultInLabel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__DiGraph = {"_p_gum__DiGraph", "gum::DiGraph *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__DiscreteVariable = {"_p_gum__DiscreteVariable", "gum::DiscreteVariable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__DiscretizedVariableT_double_t = {"_p_gum__DiscretizedVariableT_double_t", "gum::DiscretizedVariable< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__DuplicateElement = {"_p_gum__DuplicateElement", "gum::DuplicateElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__DuplicateLabel = {"_p_gum__DuplicateLabel", "gum::DuplicateLabel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__Edge = {"_p_gum__Edge", "gum::Edge *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__EdgeGraphPart = {"_p_gum__EdgeGraphPart", "gum::EdgeGraphPart *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__EmptyBSTree = {"_p_gum__EmptyBSTree", "gum::EmptyBSTree *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__EmptySet = {"_p_gum__EmptySet", "gum::EmptySet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__EssentialGraph = {"_p_gum__EssentialGraph", "gum::EssentialGraph *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__ExactBNdistanceT_double_t = {"_p_gum__ExactBNdistanceT_double_t", "gum::ExactBNdistance< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__Exception = {"_p_gum__Exception", "gum::Exception *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__FactoryError = {"_p_gum__FactoryError", "gum::FactoryError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__FactoryInvalidState = {"_p_gum__FactoryInvalidState", "gum::FactoryInvalidState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__FatalError = {"_p_gum__FatalError", "gum::FatalError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__FormatNotFound = {"_p_gum__FormatNotFound", "gum::FormatNotFound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__GibbsBNdistanceT_double_t = {"_p_gum__GibbsBNdistanceT_double_t", "gum::GibbsBNdistance< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__GibbsSamplingT_double_t = {"_p_gum__GibbsSamplingT_double_t", "gum::GibbsSampling< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__GraphError = {"_p_gum__GraphError", "gum::GraphError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__IApproximationSchemeConfiguration = {"_p_gum__IApproximationSchemeConfiguration", "gum::IApproximationSchemeConfiguration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__IBayesNetT_double_t = {"_p_gum__IBayesNetT_double_t", "gum::IBayesNet< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__IDiscretizedVariable = {"_p_gum__IDiscretizedVariable", "gum::IDiscretizedVariable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__IOError = {"_p_gum__IOError", "gum::IOError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__IdError = {"_p_gum__IdError", "gum::IdError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__ImportanceSamplingT_double_t = {"_p_gum__ImportanceSamplingT_double_t", "gum::ImportanceSampling< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__IncompatibleEvidence = {"_p_gum__IncompatibleEvidence", "gum::IncompatibleEvidence *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__IncompatibleScoreApriori = {"_p_gum__IncompatibleScoreApriori", "gum::IncompatibleScoreApriori *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__InfluenceDiagramInferenceT_double_t = {"_p_gum__InfluenceDiagramInferenceT_double_t", "gum::InfluenceDiagramInference< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__InfluenceDiagramT_double_t = {"_p_gum__InfluenceDiagramT_double_t", "gum::InfluenceDiagram< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__Instantiation = {"_p_gum__Instantiation", "gum::Instantiation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__InvalidArc = {"_p_gum__InvalidArc", "gum::InvalidArc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__InvalidArgument = {"_p_gum__InvalidArgument", "gum::InvalidArgument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__InvalidArgumentsNumber = {"_p_gum__InvalidArgumentsNumber", "gum::InvalidArgumentsNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__InvalidDirectedCycle = {"_p_gum__InvalidDirectedCycle", "gum::InvalidDirectedCycle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__InvalidEdge = {"_p_gum__InvalidEdge", "gum::InvalidEdge *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__InvalidNode = {"_p_gum__InvalidNode", "gum::InvalidNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__LabelizedVariable = {"_p_gum__LabelizedVariable", "gum::LabelizedVariable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__LazyPropagationT_double_t = {"_p_gum__LazyPropagationT_double_t", "gum::LazyPropagation< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__LearningError = {"_p_gum__LearningError", "gum::LearningError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__ListT_gum__PotentialT_double_t_const_p_t = {"_p_gum__ListT_gum__PotentialT_double_t_const_p_t", "gum::List< gum::Potential< double > const * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__LoopyBeliefPropagationT_double_t = {"_p_gum__LoopyBeliefPropagationT_double_t", "gum::LoopyBeliefPropagation< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t = {"_p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t", "gum::LoopySamplingInference< double,gum::GibbsSampling > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t = {"_p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t", "gum::LoopySamplingInference< double,gum::ImportanceSampling > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t = {"_p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t", "gum::LoopySamplingInference< double,gum::MonteCarloSampling > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t = {"_p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t", "gum::LoopySamplingInference< double,gum::WeightedSampling > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__MarkovBlanket = {"_p_gum__MarkovBlanket", "gum::MarkovBlanket *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__MissingValueInDatabase = {"_p_gum__MissingValueInDatabase", "gum::MissingValueInDatabase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__MissingVariableInDatabase = {"_p_gum__MissingVariableInDatabase", "gum::MissingVariableInDatabase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__MixedGraph = {"_p_gum__MixedGraph", "gum::MixedGraph *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__MonteCarloSamplingT_double_t = {"_p_gum__MonteCarloSamplingT_double_t", "gum::MonteCarloSampling< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__MultiDimAdressable = {"_p_gum__MultiDimAdressable", "gum::MultiDimAdressable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__MultiDimArrayT_double_t = {"_p_gum__MultiDimArrayT_double_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_gum__MultiDimContainerT_double_t = {"_p_gum__MultiDimContainerT_double_t", "gum::MultiDimContainer< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__MultiDimDecoratorT_double_t = {"_p_gum__MultiDimDecoratorT_double_t", "gum::MultiDimDecorator< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__MultiDimImplementationT_double_t = {"_p_gum__MultiDimImplementationT_double_t", "gum::MultiDimImplementation< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__MultiDimInterface = {"_p_gum__MultiDimInterface", "gum::MultiDimInterface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__MultiDimWithOffsetT_double_t = {"_p_gum__MultiDimWithOffsetT_double_t", "gum::MultiDimWithOffset< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__NoChild = {"_p_gum__NoChild", "gum::NoChild *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__NoNeighbour = {"_p_gum__NoNeighbour", "gum::NoNeighbour *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__NoParent = {"_p_gum__NoParent", "gum::NoParent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__NodeGraphPart = {"_p_gum__NodeGraphPart", "gum::NodeGraphPart *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__NodePropertyT_gum__PotentialT_double_t_const_p_t = {"_p_gum__NodePropertyT_gum__PotentialT_double_t_const_p_t", "gum::NodeProperty< gum::Potential< double > const * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__NodePropertyT_std__size_t_t = {"_p_gum__NodePropertyT_std__size_t_t", "gum::NodeProperty< gum::Idx > *|gum::NodeProperty< gum::NodeId > *|gum::NodeProperty< std::size_t > *|gum::NodeProperty< gum::Size > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t = {"_p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t", "gum::NodeProperty< std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__NotFound = {"_p_gum__NotFound", "gum::NotFound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__NotImplementedYet = {"_p_gum__NotImplementedYet", "gum::NotImplementedYet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__NullElement = {"_p_gum__NullElement", "gum::NullElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__OperationNotAllowed = {"_p_gum__OperationNotAllowed", "gum::OperationNotAllowed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__OutOfBounds = {"_p_gum__OutOfBounds", "gum::OutOfBounds *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__OutOfLowerBound = {"_p_gum__OutOfLowerBound", "gum::OutOfLowerBound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__OutOfUpperBound = {"_p_gum__OutOfUpperBound", "gum::OutOfUpperBound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__PossiblyIncompatibleScoreApriori = {"_p_gum__PossiblyIncompatibleScoreApriori", "gum::PossiblyIncompatibleScoreApriori *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__PotentialT_double_t = {"_p_gum__PotentialT_double_t", "gum::Potential< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__RangeVariable = {"_p_gum__RangeVariable", "gum::RangeVariable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__ReferenceError = {"_p_gum__ReferenceError", "gum::ReferenceError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SequenceT_gum__DiscreteVariable_const_p_t = {"_p_gum__SequenceT_gum__DiscreteVariable_const_p_t", "gum::Sequence< gum::DiscreteVariable const * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SequenceT_std__size_t_t = {"_p_gum__SequenceT_std__size_t_t", "gum::Sequence< gum::NodeId > *|gum::Sequence< std::size_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SetIteratorStaticEnd = {"_p_gum__SetIteratorStaticEnd", "gum::SetIteratorStaticEnd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SetT_gum__Arc_t = {"_p_gum__SetT_gum__Arc_t", "gum::Set< gum::Arc > *|gum::ArcSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SetT_gum__Arc_t__const_iterator = {"_p_gum__SetT_gum__Arc_t__const_iterator", "gum::Set< gum::Arc >::const_iterator *|gum::ArcSetIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SetT_gum__Edge_t = {"_p_gum__SetT_gum__Edge_t", "gum::Set< gum::Edge > *|gum::EdgeSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SetT_gum__Edge_t__const_iterator = {"_p_gum__SetT_gum__Edge_t__const_iterator", "gum::Set< gum::Edge >::const_iterator *|gum::EdgeSetIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SetT_gum__PotentialT_double_t_const_p_t = {"_p_gum__SetT_gum__PotentialT_double_t_const_p_t", "gum::Set< gum::Potential< double > const * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SetT_std__size_t_t = {"_p_gum__SetT_std__size_t_t", "gum::Set< std::size_t > *|gum::NodeSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SetT_std__size_t_t__const_iterator = {"_p_gum__SetT_std__size_t_t__const_iterator", "gum::Set< std::size_t >::const_iterator *|gum::NodeSetIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__ShaferShenoyInferenceT_double_t = {"_p_gum__ShaferShenoyInferenceT_double_t", "gum::ShaferShenoyInference< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SizeError = {"_p_gum__SizeError", "gum::SizeError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__StructuralComparator = {"_p_gum__StructuralComparator", "gum::StructuralComparator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__SyntaxError = {"_p_gum__SyntaxError", "gum::SyntaxError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__Triangulation = {"_p_gum__Triangulation", "gum::Triangulation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__TypeError = {"_p_gum__TypeError", "gum::TypeError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__UndefinedElement = {"_p_gum__UndefinedElement", "gum::UndefinedElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__UndefinedIteratorKey = {"_p_gum__UndefinedIteratorKey", "gum::UndefinedIteratorKey *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__UndefinedIteratorValue = {"_p_gum__UndefinedIteratorValue", "gum::UndefinedIteratorValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__UndiGraph = {"_p_gum__UndiGraph", "gum::UndiGraph *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__UnknownLabelInDatabase = {"_p_gum__UnknownLabelInDatabase", "gum::UnknownLabelInDatabase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__Variable = {"_p_gum__Variable", "gum::Variable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__VariableEliminationT_double_t = {"_p_gum__VariableEliminationT_double_t", "gum::VariableElimination< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__VariableNodeMap = {"_p_gum__VariableNodeMap", "gum::VariableNodeMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__WeightedSamplingT_double_t = {"_p_gum__WeightedSamplingT_double_t", "gum::WeightedSampling< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__WrongClassElement = {"_p_gum__WrongClassElement", "gum::WrongClassElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__WrongType = {"_p_gum__WrongType", "gum::WrongType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__credal__CNLoopyPropagationT_double_t = {"_p_gum__credal__CNLoopyPropagationT_double_t", "gum::credal::CNLoopyPropagation< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t = {"_p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t", "gum::credal::CNMonteCarloSampling< double,gum::LazyPropagation< double > > *|gum::credal::CNMonteCarloSampling< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__credal__CredalNetT_double_t = {"_p_gum__credal__CredalNetT_double_t", "gum::credal::CredalNet< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__learning__BNDatabaseGeneratorT_double_t = {"_p_gum__learning__BNDatabaseGeneratorT_double_t", "gum::learning::BNDatabaseGenerator< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__learning__BNLearnerT_double_t = {"_p_gum__learning__BNLearnerT_double_t", "gum::learning::BNLearner< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__learning__DatabaseTableT_std__allocator_t = {"_p_gum__learning__DatabaseTableT_std__allocator_t", "gum::learning::DatabaseTable< std::allocator > *|gum::learning::DatabaseTable< > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_gum__learning__genericBNLearner = {"_p_gum__learning__genericBNLearner", "gum::learning::genericBNLearner *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iterator_category = {"_p_iterator_category", "iterator_category *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_msg = {"_p_msg", "msg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_node_const_iterator = {"_p_node_const_iterator", "node_const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_node_const_iterator_safe = {"_p_node_const_iterator_safe", "node_const_iterator_safe *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_node_iterator = {"_p_node_iterator", "node_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_node_iterator_safe = {"_p_node_iterator_safe", "node_iterator_safe *", 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_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_double_t = {"_p_std__allocatorT_double_t", "std::vector< double >::allocator_type *|std::allocator< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__allocatorT_std__string_t", "std::vector< std::string >::allocator_type *|std::allocator< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_unsigned_int_t = {"_p_std__allocatorT_unsigned_int_t", "std::vector< unsigned int >::allocator_type *|std::allocator< unsigned int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__default_random_engine = {"_p_std__default_random_engine", "std::default_random_engine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_double_fdoubleF_t = {"_p_std__functionT_double_fdoubleF_t", "std::function< double (double) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_double_fdouble_doubleF_t = {"_p_std__functionT_double_fdouble_doubleF_t", "std::function< double (double,double) > *", 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__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__size_t = {"_p_std__size_t", "gum::Size *|std::size_t *|gum::Idx *|gum::NodeId *", 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_PythonLoadListener_std__allocatorT_PythonLoadListener_t_t = {"_p_std__vectorT_PythonLoadListener_std__allocatorT_PythonLoadListener_t_t", "std::vector< PythonLoadListener,std::allocator< PythonLoadListener > > *", 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_gum__Arc_std__allocatorT_gum__Arc_t_t = {"_p_std__vectorT_gum__Arc_std__allocatorT_gum__Arc_t_t", "std::vector< gum::Arc,std::allocator< gum::Arc > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_gum__DiscreteVariable_const_p_std__allocatorT_gum__DiscreteVariable_const_p_t_t = {"_p_std__vectorT_gum__DiscreteVariable_const_p_std__allocatorT_gum__DiscreteVariable_const_p_t_t", "std::vector< gum::DiscreteVariable const *,std::allocator< gum::DiscreteVariable const * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t = {"_p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t", "std::vector< gum::NodeId,std::allocator< gum::NodeId > > *|std::vector< gum::Idx,std::allocator< gum::Idx > > *|std::vector< std::size_t,std::allocator< std::size_t > > *", 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::allocator< std::string > > *|std::vector< 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::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_std__allocatorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t = {"_p_std__vectorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_std__allocatorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t", "std::vector< std::vector< std::size_t,std::allocator< std::size_t > >,std::allocator< std::vector< std::size_t,std::allocator< std::size_t > > > > *|std::vector< std::vector< gum::Idx,std::allocator< gum::Idx > >,std::allocator< std::vector< gum::Idx,std::allocator< gum::Idx > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t = {"_p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t", "std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t = {"_p_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t", "std::vector< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::allocator< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t = {"_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t", "std::vector< unsigned int,std::allocator< unsigned int > > *|std::vector< unsigned int > *", 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_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_ArcIterator,
  &_swigt__p_BNGenerator,
  &_swigt__p_EdgeIterator,
  &_swigt__p_IDGenerator,
  &_swigt__p_JunctionTreeGenerator,
  &_swigt__p_NodeConstIterator,
  &_swigt__p_NodeConstIteratorSafe,
  &_swigt__p_NodeIterator,
  &_swigt__p_NodeIteratorSafe,
  &_swigt__p_PRMexplorer,
  &_swigt__p_PythonApproximationListener,
  &_swigt__p_PythonBNListener,
  &_swigt__p_PythonDatabaseGeneratorListener,
  &_swigt__p_PythonLoadListener,
  &_swigt__p_allocator_type,
  &_swigt__p_char,
  &_swigt__p_difference_type,
  &_swigt__p_gum__ApproximationScheme,
  &_swigt__p_gum__Arc,
  &_swigt__p_gum__ArcGraphPart,
  &_swigt__p_gum__BNdistanceT_double_t,
  &_swigt__p_gum__BayesNetInferenceT_double_t,
  &_swigt__p_gum__BayesNetT_double_t,
  &_swigt__p_gum__CPTError,
  &_swigt__p_gum__CPTNoSumTo1,
  &_swigt__p_gum__CliqueGraph,
  &_swigt__p_gum__DAG,
  &_swigt__p_gum__DAGmodel,
  &_swigt__p_gum__DatabaseError,
  &_swigt__p_gum__DefaultInLabel,
  &_swigt__p_gum__DiGraph,
  &_swigt__p_gum__DiscreteVariable,
  &_swigt__p_gum__DiscretizedVariableT_double_t,
  &_swigt__p_gum__DuplicateElement,
  &_swigt__p_gum__DuplicateLabel,
  &_swigt__p_gum__Edge,
  &_swigt__p_gum__EdgeGraphPart,
  &_swigt__p_gum__EmptyBSTree,
  &_swigt__p_gum__EmptySet,
  &_swigt__p_gum__EssentialGraph,
  &_swigt__p_gum__ExactBNdistanceT_double_t,
  &_swigt__p_gum__Exception,
  &_swigt__p_gum__FactoryError,
  &_swigt__p_gum__FactoryInvalidState,
  &_swigt__p_gum__FatalError,
  &_swigt__p_gum__FormatNotFound,
  &_swigt__p_gum__GibbsBNdistanceT_double_t,
  &_swigt__p_gum__GibbsSamplingT_double_t,
  &_swigt__p_gum__GraphError,
  &_swigt__p_gum__IApproximationSchemeConfiguration,
  &_swigt__p_gum__IBayesNetT_double_t,
  &_swigt__p_gum__IDiscretizedVariable,
  &_swigt__p_gum__IOError,
  &_swigt__p_gum__IdError,
  &_swigt__p_gum__ImportanceSamplingT_double_t,
  &_swigt__p_gum__IncompatibleEvidence,
  &_swigt__p_gum__IncompatibleScoreApriori,
  &_swigt__p_gum__InfluenceDiagramInferenceT_double_t,
  &_swigt__p_gum__InfluenceDiagramT_double_t,
  &_swigt__p_gum__Instantiation,
  &_swigt__p_gum__InvalidArc,
  &_swigt__p_gum__InvalidArgument,
  &_swigt__p_gum__InvalidArgumentsNumber,
  &_swigt__p_gum__InvalidDirectedCycle,
  &_swigt__p_gum__InvalidEdge,
  &_swigt__p_gum__InvalidNode,
  &_swigt__p_gum__LabelizedVariable,
  &_swigt__p_gum__LazyPropagationT_double_t,
  &_swigt__p_gum__LearningError,
  &_swigt__p_gum__ListT_gum__PotentialT_double_t_const_p_t,
  &_swigt__p_gum__LoopyBeliefPropagationT_double_t,
  &_swigt__p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t,
  &_swigt__p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t,
  &_swigt__p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t,
  &_swigt__p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t,
  &_swigt__p_gum__MarkovBlanket,
  &_swigt__p_gum__MissingValueInDatabase,
  &_swigt__p_gum__MissingVariableInDatabase,
  &_swigt__p_gum__MixedGraph,
  &_swigt__p_gum__MonteCarloSamplingT_double_t,
  &_swigt__p_gum__MultiDimAdressable,
  &_swigt__p_gum__MultiDimArrayT_double_t,
  &_swigt__p_gum__MultiDimContainerT_double_t,
  &_swigt__p_gum__MultiDimDecoratorT_double_t,
  &_swigt__p_gum__MultiDimImplementationT_double_t,
  &_swigt__p_gum__MultiDimInterface,
  &_swigt__p_gum__MultiDimWithOffsetT_double_t,
  &_swigt__p_gum__NoChild,
  &_swigt__p_gum__NoNeighbour,
  &_swigt__p_gum__NoParent,
  &_swigt__p_gum__NodeGraphPart,
  &_swigt__p_gum__NodePropertyT_gum__PotentialT_double_t_const_p_t,
  &_swigt__p_gum__NodePropertyT_std__size_t_t,
  &_swigt__p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t,
  &_swigt__p_gum__NotFound,
  &_swigt__p_gum__NotImplementedYet,
  &_swigt__p_gum__NullElement,
  &_swigt__p_gum__OperationNotAllowed,
  &_swigt__p_gum__OutOfBounds,
  &_swigt__p_gum__OutOfLowerBound,
  &_swigt__p_gum__OutOfUpperBound,
  &_swigt__p_gum__PossiblyIncompatibleScoreApriori,
  &_swigt__p_gum__PotentialT_double_t,
  &_swigt__p_gum__RangeVariable,
  &_swigt__p_gum__ReferenceError,
  &_swigt__p_gum__SequenceT_gum__DiscreteVariable_const_p_t,
  &_swigt__p_gum__SequenceT_std__size_t_t,
  &_swigt__p_gum__SetIteratorStaticEnd,
  &_swigt__p_gum__SetT_gum__Arc_t,
  &_swigt__p_gum__SetT_gum__Arc_t__const_iterator,
  &_swigt__p_gum__SetT_gum__Edge_t,
  &_swigt__p_gum__SetT_gum__Edge_t__const_iterator,
  &_swigt__p_gum__SetT_gum__PotentialT_double_t_const_p_t,
  &_swigt__p_gum__SetT_std__size_t_t,
  &_swigt__p_gum__SetT_std__size_t_t__const_iterator,
  &_swigt__p_gum__ShaferShenoyInferenceT_double_t,
  &_swigt__p_gum__SizeError,
  &_swigt__p_gum__StructuralComparator,
  &_swigt__p_gum__SyntaxError,
  &_swigt__p_gum__Triangulation,
  &_swigt__p_gum__TypeError,
  &_swigt__p_gum__UndefinedElement,
  &_swigt__p_gum__UndefinedIteratorKey,
  &_swigt__p_gum__UndefinedIteratorValue,
  &_swigt__p_gum__UndiGraph,
  &_swigt__p_gum__UnknownLabelInDatabase,
  &_swigt__p_gum__Variable,
  &_swigt__p_gum__VariableEliminationT_double_t,
  &_swigt__p_gum__VariableNodeMap,
  &_swigt__p_gum__WeightedSamplingT_double_t,
  &_swigt__p_gum__WrongClassElement,
  &_swigt__p_gum__WrongType,
  &_swigt__p_gum__credal__CNLoopyPropagationT_double_t,
  &_swigt__p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t,
  &_swigt__p_gum__credal__CredalNetT_double_t,
  &_swigt__p_gum__learning__BNDatabaseGeneratorT_double_t,
  &_swigt__p_gum__learning__BNLearnerT_double_t,
  &_swigt__p_gum__learning__DatabaseTableT_std__allocator_t,
  &_swigt__p_gum__learning__genericBNLearner,
  &_swigt__p_iterator_category,
  &_swigt__p_msg,
  &_swigt__p_node_const_iterator,
  &_swigt__p_node_const_iterator_safe,
  &_swigt__p_node_iterator,
  &_swigt__p_node_iterator_safe,
  &_swigt__p_p_PyObject,
  &_swigt__p_size_type,
  &_swigt__p_std__allocatorT_double_t,
  &_swigt__p_std__allocatorT_std__string_t,
  &_swigt__p_std__allocatorT_unsigned_int_t,
  &_swigt__p_std__default_random_engine,
  &_swigt__p_std__functionT_double_fdoubleF_t,
  &_swigt__p_std__functionT_double_fdouble_doubleF_t,
  &_swigt__p_std__invalid_argument,
  &_swigt__p_std__ostream,
  &_swigt__p_std__size_t,
  &_swigt__p_std__string,
  &_swigt__p_std__vectorT_PythonLoadListener_std__allocatorT_PythonLoadListener_t_t,
  &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t,
  &_swigt__p_std__vectorT_gum__Arc_std__allocatorT_gum__Arc_t_t,
  &_swigt__p_std__vectorT_gum__DiscreteVariable_const_p_std__allocatorT_gum__DiscreteVariable_const_p_t_t,
  &_swigt__p_std__vectorT_std__size_t_std__allocatorT_std__size_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_std__vectorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_std__allocatorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t,
  &_swigt__p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t,
  &_swigt__p_swig__SwigPyIterator,
  &_swigt__p_value_type,
  &_swigt__p_void,
};

static swig_cast_info _swigc__p_ArcIterator[] = {  {&_swigt__p_ArcIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BNGenerator[] = {  {&_swigt__p_BNGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EdgeIterator[] = {  {&_swigt__p_EdgeIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IDGenerator[] = {  {&_swigt__p_IDGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_JunctionTreeGenerator[] = {  {&_swigt__p_JunctionTreeGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NodeConstIterator[] = {  {&_swigt__p_NodeConstIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NodeConstIteratorSafe[] = {  {&_swigt__p_NodeConstIteratorSafe, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NodeIterator[] = {  {&_swigt__p_NodeIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NodeIteratorSafe[] = {  {&_swigt__p_NodeIteratorSafe, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PRMexplorer[] = {  {&_swigt__p_PRMexplorer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PythonApproximationListener[] = {  {&_swigt__p_PythonApproximationListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PythonBNListener[] = {  {&_swigt__p_PythonBNListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PythonDatabaseGeneratorListener[] = {  {&_swigt__p_PythonDatabaseGeneratorListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PythonLoadListener[] = {  {&_swigt__p_PythonLoadListener, 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_char[] = {  {&_swigt__p_char, 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_gum__ApproximationScheme[] = {  {&_swigt__p_gum__GibbsBNdistanceT_double_t, _p_gum__GibbsBNdistanceT_double_tTo_p_gum__ApproximationScheme, 0, 0},  {&_swigt__p_gum__ApproximationScheme, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__Arc[] = {  {&_swigt__p_gum__Arc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__ArcGraphPart[] = {  {&_swigt__p_gum__DiGraph, _p_gum__DiGraphTo_p_gum__ArcGraphPart, 0, 0},  {&_swigt__p_gum__DAG, _p_gum__DAGTo_p_gum__ArcGraphPart, 0, 0},  {&_swigt__p_gum__MixedGraph, _p_gum__MixedGraphTo_p_gum__ArcGraphPart, 0, 0},  {&_swigt__p_gum__ArcGraphPart, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__BNdistanceT_double_t[] = {  {&_swigt__p_gum__BNdistanceT_double_t, 0, 0, 0},  {&_swigt__p_gum__ExactBNdistanceT_double_t, _p_gum__ExactBNdistanceT_double_tTo_p_gum__BNdistanceT_double_t, 0, 0},  {&_swigt__p_gum__GibbsBNdistanceT_double_t, _p_gum__GibbsBNdistanceT_double_tTo_p_gum__BNdistanceT_double_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__BayesNetInferenceT_double_t[] = {  {&_swigt__p_gum__BayesNetInferenceT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__BayesNetT_double_t[] = {  {&_swigt__p_gum__BayesNetT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__CPTError[] = {  {&_swigt__p_gum__CPTNoSumTo1, _p_gum__CPTNoSumTo1To_p_gum__CPTError, 0, 0},  {&_swigt__p_gum__CPTError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__CPTNoSumTo1[] = {  {&_swigt__p_gum__CPTNoSumTo1, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__CliqueGraph[] = {  {&_swigt__p_gum__CliqueGraph, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__DAG[] = {  {&_swigt__p_gum__DAG, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__DAGmodel[] = {  {&_swigt__p_gum__DAGmodel, 0, 0, 0},  {&_swigt__p_gum__IBayesNetT_double_t, _p_gum__IBayesNetT_double_tTo_p_gum__DAGmodel, 0, 0},  {&_swigt__p_gum__BayesNetT_double_t, _p_gum__BayesNetT_double_tTo_p_gum__DAGmodel, 0, 0},  {&_swigt__p_gum__InfluenceDiagramT_double_t, _p_gum__InfluenceDiagramT_double_tTo_p_gum__DAGmodel, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__DatabaseError[] = {  {&_swigt__p_gum__DatabaseError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__DefaultInLabel[] = {  {&_swigt__p_gum__DefaultInLabel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__DiGraph[] = {  {&_swigt__p_gum__DiGraph, 0, 0, 0},  {&_swigt__p_gum__DAG, _p_gum__DAGTo_p_gum__DiGraph, 0, 0},  {&_swigt__p_gum__MixedGraph, _p_gum__MixedGraphTo_p_gum__DiGraph, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__DiscreteVariable[] = {  {&_swigt__p_gum__DiscreteVariable, 0, 0, 0},  {&_swigt__p_gum__LabelizedVariable, _p_gum__LabelizedVariableTo_p_gum__DiscreteVariable, 0, 0},  {&_swigt__p_gum__RangeVariable, _p_gum__RangeVariableTo_p_gum__DiscreteVariable, 0, 0},  {&_swigt__p_gum__IDiscretizedVariable, _p_gum__IDiscretizedVariableTo_p_gum__DiscreteVariable, 0, 0},  {&_swigt__p_gum__DiscretizedVariableT_double_t, _p_gum__DiscretizedVariableT_double_tTo_p_gum__DiscreteVariable, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__DiscretizedVariableT_double_t[] = {  {&_swigt__p_gum__DiscretizedVariableT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__DuplicateElement[] = {  {&_swigt__p_gum__DuplicateElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__DuplicateLabel[] = {  {&_swigt__p_gum__DuplicateLabel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__Edge[] = {  {&_swigt__p_gum__Edge, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__EdgeGraphPart[] = {  {&_swigt__p_gum__UndiGraph, _p_gum__UndiGraphTo_p_gum__EdgeGraphPart, 0, 0},  {&_swigt__p_gum__MixedGraph, _p_gum__MixedGraphTo_p_gum__EdgeGraphPart, 0, 0},  {&_swigt__p_gum__EdgeGraphPart, 0, 0, 0},  {&_swigt__p_gum__CliqueGraph, _p_gum__CliqueGraphTo_p_gum__EdgeGraphPart, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__EmptyBSTree[] = {  {&_swigt__p_gum__EmptyBSTree, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__EmptySet[] = {  {&_swigt__p_gum__EmptySet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__EssentialGraph[] = {  {&_swigt__p_gum__EssentialGraph, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__ExactBNdistanceT_double_t[] = {  {&_swigt__p_gum__ExactBNdistanceT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__Exception[] = {  {&_swigt__p_gum__WrongType, _p_gum__WrongTypeTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__FatalError, _p_gum__FatalErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__IncompatibleScoreApriori, _p_gum__IncompatibleScoreAprioriTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__PossiblyIncompatibleScoreApriori, _p_gum__PossiblyIncompatibleScoreAprioriTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__InvalidNode, _p_gum__InvalidNodeTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__NotFound, _p_gum__NotFoundTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__FormatNotFound, _p_gum__FormatNotFoundTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__GraphError, _p_gum__GraphErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__DefaultInLabel, _p_gum__DefaultInLabelTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__InvalidDirectedCycle, _p_gum__InvalidDirectedCycleTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__DatabaseError, _p_gum__DatabaseErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__ReferenceError, _p_gum__ReferenceErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__OperationNotAllowed, _p_gum__OperationNotAllowedTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__FactoryError, _p_gum__FactoryErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__CPTError, _p_gum__CPTErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__InvalidArc, _p_gum__InvalidArcTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__SyntaxError, _p_gum__SyntaxErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__OutOfUpperBound, _p_gum__OutOfUpperBoundTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__OutOfLowerBound, _p_gum__OutOfLowerBoundTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__SizeError, _p_gum__SizeErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__TypeError, _p_gum__TypeErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__DuplicateLabel, _p_gum__DuplicateLabelTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__LearningError, _p_gum__LearningErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__InvalidEdge, _p_gum__InvalidEdgeTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__Exception, 0, 0, 0},  {&_swigt__p_gum__InvalidArgumentsNumber, _p_gum__InvalidArgumentsNumberTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__UndefinedIteratorValue, _p_gum__UndefinedIteratorValueTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__IdError, _p_gum__IdErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__InvalidArgument, _p_gum__InvalidArgumentTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__NoNeighbour, _p_gum__NoNeighbourTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__OutOfBounds, _p_gum__OutOfBoundsTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__EmptyBSTree, _p_gum__EmptyBSTreeTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__CPTNoSumTo1, _p_gum__CPTNoSumTo1To_p_gum__Exception, 0, 0},  {&_swigt__p_gum__IncompatibleEvidence, _p_gum__IncompatibleEvidenceTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__NoParent, _p_gum__NoParentTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__WrongClassElement, _p_gum__WrongClassElementTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__DuplicateElement, _p_gum__DuplicateElementTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__NullElement, _p_gum__NullElementTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__UndefinedElement, _p_gum__UndefinedElementTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__NoChild, _p_gum__NoChildTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__FactoryInvalidState, _p_gum__FactoryInvalidStateTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__EmptySet, _p_gum__EmptySetTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__IOError, _p_gum__IOErrorTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__MissingVariableInDatabase, _p_gum__MissingVariableInDatabaseTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__MissingValueInDatabase, _p_gum__MissingValueInDatabaseTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__UnknownLabelInDatabase, _p_gum__UnknownLabelInDatabaseTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__UndefinedIteratorKey, _p_gum__UndefinedIteratorKeyTo_p_gum__Exception, 0, 0},  {&_swigt__p_gum__NotImplementedYet, _p_gum__NotImplementedYetTo_p_gum__Exception, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__FactoryError[] = {  {&_swigt__p_gum__WrongClassElement, _p_gum__WrongClassElementTo_p_gum__FactoryError, 0, 0},  {&_swigt__p_gum__FactoryError, 0, 0, 0},  {&_swigt__p_gum__FactoryInvalidState, _p_gum__FactoryInvalidStateTo_p_gum__FactoryError, 0, 0},  {&_swigt__p_gum__TypeError, _p_gum__TypeErrorTo_p_gum__FactoryError, 0, 0},  {&_swigt__p_gum__WrongType, _p_gum__WrongTypeTo_p_gum__FactoryError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__FactoryInvalidState[] = {  {&_swigt__p_gum__FactoryInvalidState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__FatalError[] = {  {&_swigt__p_gum__FatalError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__FormatNotFound[] = {  {&_swigt__p_gum__FormatNotFound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__GibbsBNdistanceT_double_t[] = {  {&_swigt__p_gum__GibbsBNdistanceT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__GibbsSamplingT_double_t[] = {  {&_swigt__p_gum__GibbsSamplingT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__GraphError[] = {  {&_swigt__p_gum__InvalidDirectedCycle, _p_gum__InvalidDirectedCycleTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__NoNeighbour, _p_gum__NoNeighbourTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__InvalidNode, _p_gum__InvalidNodeTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__GraphError, 0, 0, 0},  {&_swigt__p_gum__DefaultInLabel, _p_gum__DefaultInLabelTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__NoChild, _p_gum__NoChildTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__InvalidEdge, _p_gum__InvalidEdgeTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__InvalidArc, _p_gum__InvalidArcTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__NoParent, _p_gum__NoParentTo_p_gum__GraphError, 0, 0},  {&_swigt__p_gum__EmptyBSTree, _p_gum__EmptyBSTreeTo_p_gum__GraphError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__IApproximationSchemeConfiguration[] = {  {&_swigt__p_gum__GibbsBNdistanceT_double_t, _p_gum__GibbsBNdistanceT_double_tTo_p_gum__IApproximationSchemeConfiguration, 0, 0},  {&_swigt__p_gum__learning__BNLearnerT_double_t, _p_gum__learning__BNLearnerT_double_tTo_p_gum__IApproximationSchemeConfiguration, 0, 0},  {&_swigt__p_gum__IApproximationSchemeConfiguration, 0, 0, 0},  {&_swigt__p_gum__ApproximationScheme, _p_gum__ApproximationSchemeTo_p_gum__IApproximationSchemeConfiguration, 0, 0},  {&_swigt__p_gum__learning__genericBNLearner, _p_gum__learning__genericBNLearnerTo_p_gum__IApproximationSchemeConfiguration, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__IBayesNetT_double_t[] = {  {&_swigt__p_gum__IBayesNetT_double_t, 0, 0, 0},  {&_swigt__p_gum__BayesNetT_double_t, _p_gum__BayesNetT_double_tTo_p_gum__IBayesNetT_double_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__IDiscretizedVariable[] = {  {&_swigt__p_gum__IDiscretizedVariable, 0, 0, 0},  {&_swigt__p_gum__DiscretizedVariableT_double_t, _p_gum__DiscretizedVariableT_double_tTo_p_gum__IDiscretizedVariable, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__IOError[] = {  {&_swigt__p_gum__FormatNotFound, _p_gum__FormatNotFoundTo_p_gum__IOError, 0, 0},  {&_swigt__p_gum__IOError, 0, 0, 0},  {&_swigt__p_gum__SyntaxError, _p_gum__SyntaxErrorTo_p_gum__IOError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__IdError[] = {  {&_swigt__p_gum__IdError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__ImportanceSamplingT_double_t[] = {  {&_swigt__p_gum__ImportanceSamplingT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__IncompatibleEvidence[] = {  {&_swigt__p_gum__IncompatibleEvidence, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__IncompatibleScoreApriori[] = {  {&_swigt__p_gum__IncompatibleScoreApriori, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__InfluenceDiagramInferenceT_double_t[] = {  {&_swigt__p_gum__InfluenceDiagramInferenceT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__InfluenceDiagramT_double_t[] = {  {&_swigt__p_gum__InfluenceDiagramT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__Instantiation[] = {  {&_swigt__p_gum__Instantiation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__InvalidArc[] = {  {&_swigt__p_gum__InvalidArc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__InvalidArgument[] = {  {&_swigt__p_gum__InvalidArgument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__InvalidArgumentsNumber[] = {  {&_swigt__p_gum__InvalidArgumentsNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__InvalidDirectedCycle[] = {  {&_swigt__p_gum__InvalidDirectedCycle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__InvalidEdge[] = {  {&_swigt__p_gum__InvalidEdge, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__InvalidNode[] = {  {&_swigt__p_gum__InvalidNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__LabelizedVariable[] = {  {&_swigt__p_gum__LabelizedVariable, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__LazyPropagationT_double_t[] = {  {&_swigt__p_gum__LazyPropagationT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__LearningError[] = {  {&_swigt__p_gum__MissingVariableInDatabase, _p_gum__MissingVariableInDatabaseTo_p_gum__LearningError, 0, 0},  {&_swigt__p_gum__MissingValueInDatabase, _p_gum__MissingValueInDatabaseTo_p_gum__LearningError, 0, 0},  {&_swigt__p_gum__UnknownLabelInDatabase, _p_gum__UnknownLabelInDatabaseTo_p_gum__LearningError, 0, 0},  {&_swigt__p_gum__LearningError, 0, 0, 0},  {&_swigt__p_gum__DatabaseError, _p_gum__DatabaseErrorTo_p_gum__LearningError, 0, 0},  {&_swigt__p_gum__IncompatibleScoreApriori, _p_gum__IncompatibleScoreAprioriTo_p_gum__LearningError, 0, 0},  {&_swigt__p_gum__PossiblyIncompatibleScoreApriori, _p_gum__PossiblyIncompatibleScoreAprioriTo_p_gum__LearningError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__ListT_gum__PotentialT_double_t_const_p_t[] = {  {&_swigt__p_gum__ListT_gum__PotentialT_double_t_const_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__LoopyBeliefPropagationT_double_t[] = {  {&_swigt__p_gum__LoopyBeliefPropagationT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t[] = {  {&_swigt__p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t[] = {  {&_swigt__p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t[] = {  {&_swigt__p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t[] = {  {&_swigt__p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__MarkovBlanket[] = {  {&_swigt__p_gum__MarkovBlanket, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__MissingValueInDatabase[] = {  {&_swigt__p_gum__MissingValueInDatabase, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__MissingVariableInDatabase[] = {  {&_swigt__p_gum__MissingVariableInDatabase, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__MixedGraph[] = {  {&_swigt__p_gum__MixedGraph, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__MonteCarloSamplingT_double_t[] = {  {&_swigt__p_gum__MonteCarloSamplingT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__MultiDimArrayT_double_t[] = {{&_swigt__p_gum__MultiDimArrayT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__MultiDimAdressable[] = {  {&_swigt__p_gum__MultiDimAdressable, 0, 0, 0},  {&_swigt__p_gum__MultiDimContainerT_double_t, _p_gum__MultiDimContainerT_double_tTo_p_gum__MultiDimAdressable, 0, 0},  {&_swigt__p_gum__MultiDimImplementationT_double_t, _p_gum__MultiDimImplementationT_double_tTo_p_gum__MultiDimAdressable, 0, 0},  {&_swigt__p_gum__MultiDimWithOffsetT_double_t, _p_gum__MultiDimWithOffsetT_double_tTo_p_gum__MultiDimAdressable, 0, 0},  {&_swigt__p_gum__MultiDimArrayT_double_t, _p_gum__MultiDimArrayT_double_tTo_p_gum__MultiDimAdressable, 0, 0},  {&_swigt__p_gum__MultiDimDecoratorT_double_t, _p_gum__MultiDimDecoratorT_double_tTo_p_gum__MultiDimAdressable, 0, 0},  {&_swigt__p_gum__PotentialT_double_t, _p_gum__PotentialT_double_tTo_p_gum__MultiDimAdressable, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__MultiDimContainerT_double_t[] = {  {&_swigt__p_gum__MultiDimContainerT_double_t, 0, 0, 0},  {&_swigt__p_gum__MultiDimImplementationT_double_t, _p_gum__MultiDimImplementationT_double_tTo_p_gum__MultiDimContainerT_double_t, 0, 0},  {&_swigt__p_gum__MultiDimWithOffsetT_double_t, _p_gum__MultiDimWithOffsetT_double_tTo_p_gum__MultiDimContainerT_double_t, 0, 0},  {&_swigt__p_gum__MultiDimArrayT_double_t, _p_gum__MultiDimArrayT_double_tTo_p_gum__MultiDimContainerT_double_t, 0, 0},  {&_swigt__p_gum__MultiDimDecoratorT_double_t, _p_gum__MultiDimDecoratorT_double_tTo_p_gum__MultiDimContainerT_double_t, 0, 0},  {&_swigt__p_gum__PotentialT_double_t, _p_gum__PotentialT_double_tTo_p_gum__MultiDimContainerT_double_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__MultiDimDecoratorT_double_t[] = {  {&_swigt__p_gum__MultiDimDecoratorT_double_t, 0, 0, 0},  {&_swigt__p_gum__PotentialT_double_t, _p_gum__PotentialT_double_tTo_p_gum__MultiDimDecoratorT_double_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__MultiDimImplementationT_double_t[] = {  {&_swigt__p_gum__MultiDimImplementationT_double_t, 0, 0, 0},  {&_swigt__p_gum__MultiDimWithOffsetT_double_t, _p_gum__MultiDimWithOffsetT_double_tTo_p_gum__MultiDimImplementationT_double_t, 0, 0},  {&_swigt__p_gum__MultiDimArrayT_double_t, _p_gum__MultiDimArrayT_double_tTo_p_gum__MultiDimImplementationT_double_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__MultiDimInterface[] = {  {&_swigt__p_gum__MultiDimInterface, 0, 0, 0},  {&_swigt__p_gum__MultiDimAdressable, _p_gum__MultiDimAdressableTo_p_gum__MultiDimInterface, 0, 0},  {&_swigt__p_gum__MultiDimContainerT_double_t, _p_gum__MultiDimContainerT_double_tTo_p_gum__MultiDimInterface, 0, 0},  {&_swigt__p_gum__MultiDimImplementationT_double_t, _p_gum__MultiDimImplementationT_double_tTo_p_gum__MultiDimInterface, 0, 0},  {&_swigt__p_gum__MultiDimWithOffsetT_double_t, _p_gum__MultiDimWithOffsetT_double_tTo_p_gum__MultiDimInterface, 0, 0},  {&_swigt__p_gum__MultiDimArrayT_double_t, _p_gum__MultiDimArrayT_double_tTo_p_gum__MultiDimInterface, 0, 0},  {&_swigt__p_gum__MultiDimDecoratorT_double_t, _p_gum__MultiDimDecoratorT_double_tTo_p_gum__MultiDimInterface, 0, 0},  {&_swigt__p_gum__PotentialT_double_t, _p_gum__PotentialT_double_tTo_p_gum__MultiDimInterface, 0, 0},  {&_swigt__p_gum__Instantiation, _p_gum__InstantiationTo_p_gum__MultiDimInterface, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__MultiDimWithOffsetT_double_t[] = {  {&_swigt__p_gum__MultiDimWithOffsetT_double_t, 0, 0, 0},  {&_swigt__p_gum__MultiDimArrayT_double_t, _p_gum__MultiDimArrayT_double_tTo_p_gum__MultiDimWithOffsetT_double_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__NoChild[] = {  {&_swigt__p_gum__NoChild, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__NoNeighbour[] = {  {&_swigt__p_gum__NoNeighbour, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__NoParent[] = {  {&_swigt__p_gum__NoParent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__NodeGraphPart[] = {  {&_swigt__p_gum__UndiGraph, _p_gum__UndiGraphTo_p_gum__NodeGraphPart, 0, 0},  {&_swigt__p_gum__DiGraph, _p_gum__DiGraphTo_p_gum__NodeGraphPart, 0, 0},  {&_swigt__p_gum__DAG, _p_gum__DAGTo_p_gum__NodeGraphPart, 0, 0},  {&_swigt__p_gum__MixedGraph, _p_gum__MixedGraphTo_p_gum__NodeGraphPart, 0, 0},  {&_swigt__p_gum__NodeGraphPart, 0, 0, 0},  {&_swigt__p_gum__CliqueGraph, _p_gum__CliqueGraphTo_p_gum__NodeGraphPart, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__NodePropertyT_gum__PotentialT_double_t_const_p_t[] = {  {&_swigt__p_gum__NodePropertyT_gum__PotentialT_double_t_const_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__NodePropertyT_std__size_t_t[] = {  {&_swigt__p_gum__NodePropertyT_std__size_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t[] = {  {&_swigt__p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__NotFound[] = {  {&_swigt__p_gum__NotFound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__NotImplementedYet[] = {  {&_swigt__p_gum__NotImplementedYet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__NullElement[] = {  {&_swigt__p_gum__NullElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__OperationNotAllowed[] = {  {&_swigt__p_gum__OperationNotAllowed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__OutOfBounds[] = {  {&_swigt__p_gum__OutOfLowerBound, _p_gum__OutOfLowerBoundTo_p_gum__OutOfBounds, 0, 0},  {&_swigt__p_gum__OutOfUpperBound, _p_gum__OutOfUpperBoundTo_p_gum__OutOfBounds, 0, 0},  {&_swigt__p_gum__OutOfBounds, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__OutOfLowerBound[] = {  {&_swigt__p_gum__OutOfLowerBound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__OutOfUpperBound[] = {  {&_swigt__p_gum__OutOfUpperBound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__PossiblyIncompatibleScoreApriori[] = {  {&_swigt__p_gum__PossiblyIncompatibleScoreApriori, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__PotentialT_double_t[] = {  {&_swigt__p_gum__PotentialT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__RangeVariable[] = {  {&_swigt__p_gum__RangeVariable, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__ReferenceError[] = {  {&_swigt__p_gum__DuplicateElement, _p_gum__DuplicateElementTo_p_gum__ReferenceError, 0, 0},  {&_swigt__p_gum__DuplicateLabel, _p_gum__DuplicateLabelTo_p_gum__ReferenceError, 0, 0},  {&_swigt__p_gum__OutOfLowerBound, _p_gum__OutOfLowerBoundTo_p_gum__ReferenceError, 0, 0},  {&_swigt__p_gum__OutOfUpperBound, _p_gum__OutOfUpperBoundTo_p_gum__ReferenceError, 0, 0},  {&_swigt__p_gum__ReferenceError, 0, 0, 0},  {&_swigt__p_gum__OutOfBounds, _p_gum__OutOfBoundsTo_p_gum__ReferenceError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__SequenceT_gum__DiscreteVariable_const_p_t[] = {  {&_swigt__p_gum__SequenceT_gum__DiscreteVariable_const_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__SequenceT_std__size_t_t[] = {  {&_swigt__p_gum__SequenceT_std__size_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__SetIteratorStaticEnd[] = {  {&_swigt__p_gum__SetIteratorStaticEnd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__SetT_gum__Arc_t[] = {  {&_swigt__p_gum__SetT_gum__Arc_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__SetT_gum__Arc_t__const_iterator[] = {  {&_swigt__p_gum__SetT_gum__Arc_t__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__SetT_gum__Edge_t[] = {  {&_swigt__p_gum__SetT_gum__Edge_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__SetT_gum__Edge_t__const_iterator[] = {  {&_swigt__p_gum__SetT_gum__Edge_t__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__SetT_gum__PotentialT_double_t_const_p_t[] = {  {&_swigt__p_gum__SetT_gum__PotentialT_double_t_const_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__SetT_std__size_t_t[] = {  {&_swigt__p_gum__SetT_std__size_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__SetT_std__size_t_t__const_iterator[] = {  {&_swigt__p_gum__SetT_std__size_t_t__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__ShaferShenoyInferenceT_double_t[] = {  {&_swigt__p_gum__ShaferShenoyInferenceT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__SizeError[] = {  {&_swigt__p_gum__SizeError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__StructuralComparator[] = {  {&_swigt__p_gum__StructuralComparator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__SyntaxError[] = {  {&_swigt__p_gum__SyntaxError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__Triangulation[] = {  {&_swigt__p_gum__Triangulation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__TypeError[] = {  {&_swigt__p_gum__TypeError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__UndefinedElement[] = {  {&_swigt__p_gum__UndefinedElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__UndefinedIteratorKey[] = {  {&_swigt__p_gum__UndefinedIteratorKey, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__UndefinedIteratorValue[] = {  {&_swigt__p_gum__UndefinedIteratorValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__UndiGraph[] = {  {&_swigt__p_gum__UndiGraph, 0, 0, 0},  {&_swigt__p_gum__MixedGraph, _p_gum__MixedGraphTo_p_gum__UndiGraph, 0, 0},  {&_swigt__p_gum__CliqueGraph, _p_gum__CliqueGraphTo_p_gum__UndiGraph, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__UnknownLabelInDatabase[] = {  {&_swigt__p_gum__UnknownLabelInDatabase, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__Variable[] = {  {&_swigt__p_gum__Variable, 0, 0, 0},  {&_swigt__p_gum__DiscreteVariable, _p_gum__DiscreteVariableTo_p_gum__Variable, 0, 0},  {&_swigt__p_gum__LabelizedVariable, _p_gum__LabelizedVariableTo_p_gum__Variable, 0, 0},  {&_swigt__p_gum__RangeVariable, _p_gum__RangeVariableTo_p_gum__Variable, 0, 0},  {&_swigt__p_gum__IDiscretizedVariable, _p_gum__IDiscretizedVariableTo_p_gum__Variable, 0, 0},  {&_swigt__p_gum__DiscretizedVariableT_double_t, _p_gum__DiscretizedVariableT_double_tTo_p_gum__Variable, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__VariableEliminationT_double_t[] = {  {&_swigt__p_gum__VariableEliminationT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__VariableNodeMap[] = {  {&_swigt__p_gum__VariableNodeMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__WeightedSamplingT_double_t[] = {  {&_swigt__p_gum__WeightedSamplingT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__WrongClassElement[] = {  {&_swigt__p_gum__WrongClassElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__WrongType[] = {  {&_swigt__p_gum__WrongType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__credal__CNLoopyPropagationT_double_t[] = {  {&_swigt__p_gum__credal__CNLoopyPropagationT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t[] = {  {&_swigt__p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__credal__CredalNetT_double_t[] = {  {&_swigt__p_gum__credal__CredalNetT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__learning__BNDatabaseGeneratorT_double_t[] = {  {&_swigt__p_gum__learning__BNDatabaseGeneratorT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__learning__BNLearnerT_double_t[] = {  {&_swigt__p_gum__learning__BNLearnerT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__learning__DatabaseTableT_std__allocator_t[] = {  {&_swigt__p_gum__learning__DatabaseTableT_std__allocator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_gum__learning__genericBNLearner[] = {  {&_swigt__p_gum__learning__BNLearnerT_double_t, _p_gum__learning__BNLearnerT_double_tTo_p_gum__learning__genericBNLearner, 0, 0},  {&_swigt__p_gum__learning__genericBNLearner, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iterator_category[] = {  {&_swigt__p_iterator_category, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_msg[] = {  {&_swigt__p_msg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_node_const_iterator[] = {  {&_swigt__p_node_const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_node_const_iterator_safe[] = {  {&_swigt__p_node_const_iterator_safe, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_node_iterator[] = {  {&_swigt__p_node_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_node_iterator_safe[] = {  {&_swigt__p_node_iterator_safe, 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_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_double_t[] = {  {&_swigt__p_std__allocatorT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = {  {&_swigt__p_std__allocatorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_unsigned_int_t[] = {  {&_swigt__p_std__allocatorT_unsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__default_random_engine[] = {  {&_swigt__p_std__default_random_engine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_double_fdoubleF_t[] = {  {&_swigt__p_std__functionT_double_fdoubleF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_double_fdouble_doubleF_t[] = {  {&_swigt__p_std__functionT_double_fdouble_doubleF_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__ostream[] = {  {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__size_t[] = {  {&_swigt__p_std__size_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_PythonLoadListener_std__allocatorT_PythonLoadListener_t_t[] = {  {&_swigt__p_std__vectorT_PythonLoadListener_std__allocatorT_PythonLoadListener_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_gum__Arc_std__allocatorT_gum__Arc_t_t[] = {  {&_swigt__p_std__vectorT_gum__Arc_std__allocatorT_gum__Arc_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_gum__DiscreteVariable_const_p_std__allocatorT_gum__DiscreteVariable_const_p_t_t[] = {  {&_swigt__p_std__vectorT_gum__DiscreteVariable_const_p_std__allocatorT_gum__DiscreteVariable_const_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t[] = {  {&_swigt__p_std__vectorT_std__size_t_std__allocatorT_std__size_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_std__vectorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_std__allocatorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_std__allocatorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t[] = {  {&_swigt__p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_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_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_ArcIterator,
  _swigc__p_BNGenerator,
  _swigc__p_EdgeIterator,
  _swigc__p_IDGenerator,
  _swigc__p_JunctionTreeGenerator,
  _swigc__p_NodeConstIterator,
  _swigc__p_NodeConstIteratorSafe,
  _swigc__p_NodeIterator,
  _swigc__p_NodeIteratorSafe,
  _swigc__p_PRMexplorer,
  _swigc__p_PythonApproximationListener,
  _swigc__p_PythonBNListener,
  _swigc__p_PythonDatabaseGeneratorListener,
  _swigc__p_PythonLoadListener,
  _swigc__p_allocator_type,
  _swigc__p_char,
  _swigc__p_difference_type,
  _swigc__p_gum__ApproximationScheme,
  _swigc__p_gum__Arc,
  _swigc__p_gum__ArcGraphPart,
  _swigc__p_gum__BNdistanceT_double_t,
  _swigc__p_gum__BayesNetInferenceT_double_t,
  _swigc__p_gum__BayesNetT_double_t,
  _swigc__p_gum__CPTError,
  _swigc__p_gum__CPTNoSumTo1,
  _swigc__p_gum__CliqueGraph,
  _swigc__p_gum__DAG,
  _swigc__p_gum__DAGmodel,
  _swigc__p_gum__DatabaseError,
  _swigc__p_gum__DefaultInLabel,
  _swigc__p_gum__DiGraph,
  _swigc__p_gum__DiscreteVariable,
  _swigc__p_gum__DiscretizedVariableT_double_t,
  _swigc__p_gum__DuplicateElement,
  _swigc__p_gum__DuplicateLabel,
  _swigc__p_gum__Edge,
  _swigc__p_gum__EdgeGraphPart,
  _swigc__p_gum__EmptyBSTree,
  _swigc__p_gum__EmptySet,
  _swigc__p_gum__EssentialGraph,
  _swigc__p_gum__ExactBNdistanceT_double_t,
  _swigc__p_gum__Exception,
  _swigc__p_gum__FactoryError,
  _swigc__p_gum__FactoryInvalidState,
  _swigc__p_gum__FatalError,
  _swigc__p_gum__FormatNotFound,
  _swigc__p_gum__GibbsBNdistanceT_double_t,
  _swigc__p_gum__GibbsSamplingT_double_t,
  _swigc__p_gum__GraphError,
  _swigc__p_gum__IApproximationSchemeConfiguration,
  _swigc__p_gum__IBayesNetT_double_t,
  _swigc__p_gum__IDiscretizedVariable,
  _swigc__p_gum__IOError,
  _swigc__p_gum__IdError,
  _swigc__p_gum__ImportanceSamplingT_double_t,
  _swigc__p_gum__IncompatibleEvidence,
  _swigc__p_gum__IncompatibleScoreApriori,
  _swigc__p_gum__InfluenceDiagramInferenceT_double_t,
  _swigc__p_gum__InfluenceDiagramT_double_t,
  _swigc__p_gum__Instantiation,
  _swigc__p_gum__InvalidArc,
  _swigc__p_gum__InvalidArgument,
  _swigc__p_gum__InvalidArgumentsNumber,
  _swigc__p_gum__InvalidDirectedCycle,
  _swigc__p_gum__InvalidEdge,
  _swigc__p_gum__InvalidNode,
  _swigc__p_gum__LabelizedVariable,
  _swigc__p_gum__LazyPropagationT_double_t,
  _swigc__p_gum__LearningError,
  _swigc__p_gum__ListT_gum__PotentialT_double_t_const_p_t,
  _swigc__p_gum__LoopyBeliefPropagationT_double_t,
  _swigc__p_gum__LoopySamplingInferenceT_double_gum__GibbsSampling_t,
  _swigc__p_gum__LoopySamplingInferenceT_double_gum__ImportanceSampling_t,
  _swigc__p_gum__LoopySamplingInferenceT_double_gum__MonteCarloSampling_t,
  _swigc__p_gum__LoopySamplingInferenceT_double_gum__WeightedSampling_t,
  _swigc__p_gum__MarkovBlanket,
  _swigc__p_gum__MissingValueInDatabase,
  _swigc__p_gum__MissingVariableInDatabase,
  _swigc__p_gum__MixedGraph,
  _swigc__p_gum__MonteCarloSamplingT_double_t,
  _swigc__p_gum__MultiDimAdressable,
  _swigc__p_gum__MultiDimArrayT_double_t,
  _swigc__p_gum__MultiDimContainerT_double_t,
  _swigc__p_gum__MultiDimDecoratorT_double_t,
  _swigc__p_gum__MultiDimImplementationT_double_t,
  _swigc__p_gum__MultiDimInterface,
  _swigc__p_gum__MultiDimWithOffsetT_double_t,
  _swigc__p_gum__NoChild,
  _swigc__p_gum__NoNeighbour,
  _swigc__p_gum__NoParent,
  _swigc__p_gum__NodeGraphPart,
  _swigc__p_gum__NodePropertyT_gum__PotentialT_double_t_const_p_t,
  _swigc__p_gum__NodePropertyT_std__size_t_t,
  _swigc__p_gum__NodePropertyT_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t_t,
  _swigc__p_gum__NotFound,
  _swigc__p_gum__NotImplementedYet,
  _swigc__p_gum__NullElement,
  _swigc__p_gum__OperationNotAllowed,
  _swigc__p_gum__OutOfBounds,
  _swigc__p_gum__OutOfLowerBound,
  _swigc__p_gum__OutOfUpperBound,
  _swigc__p_gum__PossiblyIncompatibleScoreApriori,
  _swigc__p_gum__PotentialT_double_t,
  _swigc__p_gum__RangeVariable,
  _swigc__p_gum__ReferenceError,
  _swigc__p_gum__SequenceT_gum__DiscreteVariable_const_p_t,
  _swigc__p_gum__SequenceT_std__size_t_t,
  _swigc__p_gum__SetIteratorStaticEnd,
  _swigc__p_gum__SetT_gum__Arc_t,
  _swigc__p_gum__SetT_gum__Arc_t__const_iterator,
  _swigc__p_gum__SetT_gum__Edge_t,
  _swigc__p_gum__SetT_gum__Edge_t__const_iterator,
  _swigc__p_gum__SetT_gum__PotentialT_double_t_const_p_t,
  _swigc__p_gum__SetT_std__size_t_t,
  _swigc__p_gum__SetT_std__size_t_t__const_iterator,
  _swigc__p_gum__ShaferShenoyInferenceT_double_t,
  _swigc__p_gum__SizeError,
  _swigc__p_gum__StructuralComparator,
  _swigc__p_gum__SyntaxError,
  _swigc__p_gum__Triangulation,
  _swigc__p_gum__TypeError,
  _swigc__p_gum__UndefinedElement,
  _swigc__p_gum__UndefinedIteratorKey,
  _swigc__p_gum__UndefinedIteratorValue,
  _swigc__p_gum__UndiGraph,
  _swigc__p_gum__UnknownLabelInDatabase,
  _swigc__p_gum__Variable,
  _swigc__p_gum__VariableEliminationT_double_t,
  _swigc__p_gum__VariableNodeMap,
  _swigc__p_gum__WeightedSamplingT_double_t,
  _swigc__p_gum__WrongClassElement,
  _swigc__p_gum__WrongType,
  _swigc__p_gum__credal__CNLoopyPropagationT_double_t,
  _swigc__p_gum__credal__CNMonteCarloSamplingT_double_gum__LazyPropagationT_double_t_t,
  _swigc__p_gum__credal__CredalNetT_double_t,
  _swigc__p_gum__learning__BNDatabaseGeneratorT_double_t,
  _swigc__p_gum__learning__BNLearnerT_double_t,
  _swigc__p_gum__learning__DatabaseTableT_std__allocator_t,
  _swigc__p_gum__learning__genericBNLearner,
  _swigc__p_iterator_category,
  _swigc__p_msg,
  _swigc__p_node_const_iterator,
  _swigc__p_node_const_iterator_safe,
  _swigc__p_node_iterator,
  _swigc__p_node_iterator_safe,
  _swigc__p_p_PyObject,
  _swigc__p_size_type,
  _swigc__p_std__allocatorT_double_t,
  _swigc__p_std__allocatorT_std__string_t,
  _swigc__p_std__allocatorT_unsigned_int_t,
  _swigc__p_std__default_random_engine,
  _swigc__p_std__functionT_double_fdoubleF_t,
  _swigc__p_std__functionT_double_fdouble_doubleF_t,
  _swigc__p_std__invalid_argument,
  _swigc__p_std__ostream,
  _swigc__p_std__size_t,
  _swigc__p_std__string,
  _swigc__p_std__vectorT_PythonLoadListener_std__allocatorT_PythonLoadListener_t_t,
  _swigc__p_std__vectorT_double_std__allocatorT_double_t_t,
  _swigc__p_std__vectorT_gum__Arc_std__allocatorT_gum__Arc_t_t,
  _swigc__p_std__vectorT_gum__DiscreteVariable_const_p_std__allocatorT_gum__DiscreteVariable_const_p_t_t,
  _swigc__p_std__vectorT_std__size_t_std__allocatorT_std__size_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_std__vectorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_std__allocatorT_std__vectorT_std__size_t_std__allocatorT_std__size_t_t_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_std__allocatorT_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t_t_t,
  _swigc__p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t,
  _swigc__p_swig__SwigPyIterator,
  _swigc__p_value_type,
  _swigc__p_void,
};


/* -------- 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 %lu\n", (unsigned long)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 %lu %s\n", (unsigned long)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 %lu %s\n", (unsigned long)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 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 = {
#if PY_VERSION_HEX >= 0x03000000
        PyVarObject_HEAD_INIT(NULL, 0)
#else
        PyObject_HEAD_INIT(NULL)
        0,                                  /* ob_size */
#endif
        "swigvarlink",                      /* tp_name */
        sizeof(swig_varlinkobject),         /* tp_basicsize */
        0,                                  /* tp_itemsize */
        (destructor) swig_varlink_dealloc,  /* tp_dealloc */
        0,                                  /* 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 */
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
        0,                                  /* tp_del */
        0,                                  /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
        0,                                  /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
        0,                                  /* tp_allocs */
        0,                                  /* tp_frees */
        0,                                  /* tp_maxalloc */
        0,                                  /* tp_prev */
        0                                   /* tp_next */
#endif
      };
      varlink_type = tmp;
      type_init = 1;
      if (PyType_Ready(&varlink_type) < 0)
      return NULL;
    }
    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, const 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) {
        memcpy(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 *globals = 0;
    if (!globals) {
      globals = SWIG_newvarlink();
    }
    return 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;
              memcpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              memcpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
  /* -----------------------------------------------------------------------------
   * Method creation and docstring support functions
   * ----------------------------------------------------------------------------- */
  
  /* -----------------------------------------------------------------------------
   * Function to find the method definition with the correct docstring for the
   * proxy module as opposed to the low-level API
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
    /* Find the function in the modified method table */
    size_t offset = 0;
    int found = 0;
    while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
      if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
        found = 1;
        break;
      }
      offset++;
    }
    /* Use the copy with the modified docstring if available */
    return found ? &SwigMethods_proxydocs[offset] : NULL;
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyInstanceMethod_New() used in Python 3
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
#if PY_VERSION_HEX >= 0x03000000
    return PyInstanceMethod_New(func);
#else
    return PyMethod_New(func, NULL, NULL);
#endif
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyStaticMethod_New()
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
    return PyStaticMethod_New(func);
  }
  
#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, *globals;
  
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    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 = {
    SwigPyObject_own,
    SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  PyTypeObject *swigpyobject;
  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;
  
  /* Metaclass is used to implement static member variables */
  metatype = SwigPyObjectType();
  assert(metatype);
#endif
  
  (void)globals;
  
  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
  SWIG_This();
  SWIG_Python_TypeCache();
  SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
  SwigPyObject_type();
#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(SWIG_name, SwigMethods);
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  swigpyobject = SwigPyObject_TypeOnce();
  
  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;
  } else if (swigpyobject->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);
  
  SWIG_Python_SetConstant(d, "VarType_Discretized",SWIG_From_int(static_cast< int >(gum::VarType::Discretized)));
  SWIG_Python_SetConstant(d, "VarType_Labelized",SWIG_From_int(static_cast< int >(gum::VarType::Labelized)));
  SWIG_Python_SetConstant(d, "VarType_Range",SWIG_From_int(static_cast< int >(gum::VarType::Range)));
  SWIG_Python_SetConstant(d, "VarType_Continuous",SWIG_From_int(static_cast< int >(gum::VarType::Continuous)));
  SWIG_Python_SetConstant(d, "GUM_DEFAULT_ITERATOR_NUMBER",SWIG_From_int(static_cast< int >(4)));
  globals = SWIG_globals();
  if (!globals) {
    PyErr_SetString(PyExc_TypeError, "Failure to create SWIG globals.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  PyDict_SetItemString(md, "cvar", globals);
  Py_DECREF(globals);
  SWIG_addvarlink(globals, "__list_end_safe", Swig_var___list_end_safe_get, Swig_var___list_end_safe_set);
  SWIG_addvarlink(globals, "__list_end", Swig_var___list_end_get, Swig_var___list_end_set);
  SWIG_Python_SetConstant(d, "FindBarrenNodesType_FIND_NO_BARREN_NODES",SWIG_From_int(static_cast< int >(gum::FindBarrenNodesType::FIND_NO_BARREN_NODES)));
  SWIG_Python_SetConstant(d, "FindBarrenNodesType_FIND_BARREN_NODES",SWIG_From_int(static_cast< int >(gum::FindBarrenNodesType::FIND_BARREN_NODES)));
  SWIG_Python_SetConstant(d, "BayesNetInference_StateOfInference_OutdatedBNStructure",SWIG_From_int(static_cast< int >(gum::BayesNetInference< double >::StateOfInference::OutdatedBNStructure)));
  SWIG_Python_SetConstant(d, "BayesNetInference_StateOfInference_OutdatedBNPotentials",SWIG_From_int(static_cast< int >(gum::BayesNetInference< double >::StateOfInference::OutdatedBNPotentials)));
  SWIG_Python_SetConstant(d, "BayesNetInference_StateOfInference_ReadyForInference",SWIG_From_int(static_cast< int >(gum::BayesNetInference< double >::StateOfInference::ReadyForInference)));
  SWIG_Python_SetConstant(d, "BayesNetInference_StateOfInference_Done",SWIG_From_int(static_cast< int >(gum::BayesNetInference< double >::StateOfInference::Done)));
  SWIG_Python_SetConstant(d, "CredalNet_NodeType_Precise",SWIG_From_int(static_cast< int >(gum::credal::CredalNet< double >::NodeType::Precise)));
  SWIG_Python_SetConstant(d, "CredalNet_NodeType_Credal",SWIG_From_int(static_cast< int >(gum::credal::CredalNet< double >::NodeType::Credal)));
  SWIG_Python_SetConstant(d, "CredalNet_NodeType_Vacuous",SWIG_From_int(static_cast< int >(gum::credal::CredalNet< double >::NodeType::Vacuous)));
  SWIG_Python_SetConstant(d, "CredalNet_NodeType_Indic",SWIG_From_int(static_cast< int >(gum::credal::CredalNet< double >::NodeType::Indic)));
  SWIG_Python_SetConstant(d, "CNLoopyPropagation_InferenceType_nodeToNeighbours",SWIG_From_int(static_cast< int >(gum::credal::CNLoopyPropagation< double >::InferenceType::nodeToNeighbours)));
  SWIG_Python_SetConstant(d, "CNLoopyPropagation_InferenceType_ordered",SWIG_From_int(static_cast< int >(gum::credal::CNLoopyPropagation< double >::InferenceType::ordered)));
  SWIG_Python_SetConstant(d, "CNLoopyPropagation_InferenceType_randomOrder",SWIG_From_int(static_cast< int >(gum::credal::CNLoopyPropagation< double >::InferenceType::randomOrder)));
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

